home *** CD-ROM | disk | FTP | other *** search
/ Power Programmierung 2 / Power-Programmierung CD 2 (Tewi)(1994).iso / gnu / djgpp / src / gcc-257 / config / rs6000 / rs6000.md < prev    next >
Encoding:
Text File  |  1993-12-11  |  173.3 KB  |  5,519 lines
  1. ;;- Machine description for IBM RISC System 6000 (POWER) for GNU C compiler
  2. ;;   Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
  3. ;;   Contributed by Richard Kenner (kenner@nyu.edu)
  4.  
  5. ;; This file is part of GNU CC.
  6.  
  7. ;; GNU CC is free software; you can redistribute it and/or modify
  8. ;; it under the terms of the GNU General Public License as published by
  9. ;; the Free Software Foundation; either version 2, or (at your option)
  10. ;; any later version.
  11.  
  12. ;; GNU CC is distributed in the hope that it will be useful,
  13. ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. ;; GNU General Public License for more details.
  16.  
  17. ;; You should have received a copy of the GNU General Public License
  18. ;; along with GNU CC; see the file COPYING.  If not, write to
  19. ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  20.  
  21. ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
  22.  
  23. ;; Define an insn type attribute.  This is used in function unit delay
  24. ;; computations.
  25. (define_attr "type" "integer,load,fpload,imul,idiv,branch,compare,delayed_compare,fpcompare,mtlr,fp,dmul,sdiv,ddiv,ssqrt,dsqrt"
  26.   (const_string "integer"))
  27.  
  28. ;; Length (in bytes).
  29. (define_attr "length" ""
  30.   (if_then_else (eq_attr "type" "branch")
  31.         (if_then_else (and (ge (minus (pc) (match_dup 0))
  32.                        (const_int -32768))
  33.                    (lt (minus (pc) (match_dup 0))
  34.                        (const_int 32767)))
  35.                   (const_int 8)
  36.                   (const_int 12))
  37.         (const_int 4)))
  38.  
  39. ;; Processor type -- this attribute must exactly match the processor_type
  40. ;; enumeration in rs6000.h.
  41.  
  42. (define_attr "cpu" "rios1,rios2,ppc601,ppc603,ppc604,ppc620"
  43.   (const (symbol_ref "rs6000_cpu_attr")))
  44.  
  45. ; (define_function_unit NAME MULTIPLICITY SIMULTANEITY
  46. ;            TEST READY-DELAY ISSUE-DELAY [CONFLICT-LIST])
  47.  
  48. (define_function_unit "lsu" 1 0
  49.   (and (eq_attr "type" "load")
  50.        (eq_attr "cpu" "rios2,ppc603,ppc604,ppc620"))
  51.   2 0)
  52.  
  53. (define_function_unit "lsu" 1 0
  54.   (and (eq_attr "type" "fpload")
  55.        (eq_attr "cpu" "rios2,ppc603,ppc604,ppc620"))
  56.   2 0)
  57.  
  58. (define_function_unit "iu" 1 0
  59.   (and (eq_attr "type" "load")
  60.        (eq_attr "cpu" "rios1,ppc601"))
  61.   2 0)
  62.  
  63. (define_function_unit "iu" 1 0
  64.   (and (eq_attr "type" "fpload")
  65.        (eq_attr "cpu" "rios1,ppc601"))
  66.   3 0)
  67.  
  68. (define_function_unit "iu" 1 0
  69.   (and (eq_attr "type" "imul")
  70.        (eq_attr "cpu" "rios1"))
  71.   3 0)
  72.  
  73. (define_function_unit "iu" 1 0
  74.   (and (eq_attr "type" "imul")
  75.        (eq_attr "cpu" "ppc601,ppc603,ppc604,ppc620"))
  76.   5 0)
  77.  
  78. (define_function_unit "iu" 1 0
  79.   (and (eq_attr "type" "idiv")
  80.        (eq_attr "cpu" "rios1"))
  81.   19 0)
  82.  
  83. (define_function_unit "iu" 1 0
  84.   (and (eq_attr "type" "idiv")
  85.        (eq_attr "cpu" "ppc601,ppc603,ppc604,ppc620"))
  86.   36 0)
  87.  
  88. (define_function_unit "bpu" 1 0
  89.   (eq_attr "type" "compare")
  90.   4 0)
  91.  
  92. (define_function_unit "bpu" 1 0
  93.   (eq_attr "type" "delayed_compare")
  94.   5 0)
  95.  
  96. (define_function_unit "bpu" 1 0
  97.   (and (eq_attr "type" "fpcompare")
  98.        (eq_attr "cpu" "rios1,rios2"))
  99.   8 0)
  100.  
  101. (define_function_unit "bpu" 1 0
  102.   (and (eq_attr "type" "fpcompare")
  103.        (eq_attr "cpu" "ppc601,ppc603,ppc604,ppc620"))
  104.   4 0)
  105.  
  106. (define_function_unit "bpu" 1 0
  107.   (and (eq_attr "type" "mtlr")
  108.        (eq_attr "cpu" "rios1,rios2"))
  109.   5 0)
  110.  
  111. (define_function_unit "bpu" 1 0
  112.   (and (eq_attr "type" "mtlr")
  113.        (eq_attr "cpu" "ppc601,ppc603,ppc604,ppc620"))
  114.   4 0)
  115.  
  116. (define_function_unit "fpu" 1 0
  117.   (and (eq_attr "type" "fp")
  118.        (eq_attr "cpu" "rios1"))
  119.   2 0)
  120.  
  121. (define_function_unit "fpu" 1 0
  122.   (and (eq_attr "type" "fp")
  123.        (eq_attr "cpu" "ppc601,ppc603,ppc604,ppc620"))
  124.   4 0)
  125.  
  126. (define_function_unit "fpu" 1 0
  127.   (and (eq_attr "type" "dmul")
  128.        (eq_attr "cpu" "rios1"))
  129.   2 0)
  130.  
  131. (define_function_unit "fpu" 1 0
  132.   (and (eq_attr "type" "dmul")
  133.        (eq_attr "cpu" "ppc601,ppc603,ppc604,ppc620"))
  134.   5 0)
  135.  
  136. (define_function_unit "fpu" 1 0
  137.   (and (eq_attr "type" "sdiv")
  138.        (eq_attr "cpu" "rios1"))
  139.   19 0)
  140.  
  141. (define_function_unit "fpu" 1 0
  142.   (and (eq_attr "type" "sdiv")
  143.        (eq_attr "cpu" "ppc601,ppc603,ppc604,ppc620"))
  144.   17 0)
  145.  
  146. (define_function_unit "fpu" 1 0
  147.   (and (eq_attr "type" "ddiv")
  148.        (eq_attr "cpu" "rios1"))
  149.   19 0)
  150.  
  151. (define_function_unit "fpu" 1 0
  152.   (and (eq_attr "type" "ddiv")
  153.        (eq_attr "cpu" "ppc601,ppc603,ppc604,ppc620"))
  154.   31 0)
  155.  
  156. (define_function_unit "fpu" 1 0
  157.   (and (eq_attr "type" "ssqrt")
  158.        (eq_attr "cpu" "ppc603,ppc604,ppc620"))
  159.   31 0)
  160.  
  161. (define_function_unit "fpu" 1 0
  162.   (and (eq_attr "type" "dsqrt")
  163.        (eq_attr "cpu" "ppc603,ppc604,ppc620"))
  164.   31 0)
  165.  
  166. (define_function_unit "iu2" 2 0
  167.   (and (eq_attr "type" "integer")
  168.        (eq_attr "cpu" "rios2"))
  169.   1 0
  170.   [(eq_attr "type" "imul,idiv")])
  171.  
  172. (define_function_unit "imuldiv" 1 0
  173.   (and (eq_attr "type" "imul")
  174.        (eq_attr "cpu" "rios2"))
  175.   2 0
  176.   [(eq_attr "type" "integer")])
  177.  
  178. (define_function_unit "imuldiv" 1 0
  179.   (and (eq_attr "type" "idiv")
  180.        (eq_attr "cpu" "rios2"))
  181.   13 0
  182.   [(eq_attr "type" "integer")])
  183.  
  184. (define_function_unit "fpu2" 2 0
  185.   (and (eq_attr "type" "fp")
  186.        (eq_attr "cpu" "rios2"))
  187.   2 0)
  188.  
  189. (define_function_unit "fpu2" 2 0
  190.   (and (eq_attr "type" "dmul")
  191.        (eq_attr "cpu" "rios2"))
  192.   2 0)
  193.  
  194. (define_function_unit "fpu2" 2 0
  195.   (and (eq_attr "type" "sdiv")
  196.        (eq_attr "cpu" "rios2"))
  197.   17 0)
  198.  
  199. (define_function_unit "fpu2" 2 0
  200.   (and (eq_attr "type" "ddiv")
  201.        (eq_attr "cpu" "rios2"))
  202.   17 0)
  203.  
  204. (define_function_unit "fpu2" 2 0
  205.   (and (eq_attr "type" "ssqrt")
  206.        (eq_attr "cpu" "rios2"))
  207.   26 0)
  208.  
  209. (define_function_unit "fpu2" 2 0
  210.   (and (eq_attr "type" "dsqrt")
  211.        (eq_attr "cpu" "rios2"))
  212.   26 0)
  213.  
  214. ;; Start with fixed-point load and store insns.  Here we put only the more
  215. ;; complex forms.  Basic data transfer is done later.
  216.  
  217. (define_expand "zero_extendqisi2"
  218.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  219.     (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" "")))]
  220.   ""
  221.   "")
  222.  
  223. (define_insn ""
  224.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  225.     (zero_extend:SI (match_operand:QI 1 "reg_or_mem_operand" "m,r")))]
  226.   ""
  227.   "@
  228.    lbz%U1%X1 %0,%1
  229.    {rlinm|rlwinm} %0,%1,0,0xff"
  230.   [(set_attr "type" "load,*")])
  231.  
  232. (define_insn ""
  233.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  234.     (compare:CC (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r"))
  235.             (const_int 0)))
  236.    (clobber (match_scratch:SI 2 "=r"))]
  237.   ""
  238.   "{andil.|andi.} %2,%1,0xff"
  239.   [(set_attr "type" "compare")])
  240.  
  241. (define_insn ""
  242.   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
  243.     (compare:CC (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r"))
  244.             (const_int 0)))
  245.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  246.     (zero_extend:SI (match_dup 1)))]
  247.   ""
  248.   "{andil.|andi.} %0,%1,0xff"
  249.   [(set_attr "type" "compare")])
  250.  
  251. (define_expand "zero_extendqihi2"
  252.   [(set (match_operand:HI 0 "gpc_reg_operand" "")
  253.     (zero_extend:HI (match_operand:QI 1 "gpc_reg_operand" "")))]
  254.   ""
  255.   "")
  256.  
  257. (define_insn ""
  258.   [(set (match_operand:HI 0 "gpc_reg_operand" "=r,r")
  259.     (zero_extend:HI (match_operand:QI 1 "reg_or_mem_operand" "m,r")))]
  260.   ""
  261.   "@
  262.    lbz%U1%X1 %0,%1
  263.    {rlinm|rlwinm} %0,%1,0,0xff"
  264.   [(set_attr "type" "load,*")])
  265.  
  266. (define_expand "zero_extendhisi2"
  267.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  268.     (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" "")))]
  269.   ""
  270.   "")
  271.  
  272. (define_insn ""
  273.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  274.     (zero_extend:SI (match_operand:HI 1 "reg_or_mem_operand" "m,r")))]
  275.   ""
  276.   "@
  277.    lhz%U1%X1 %0,%1
  278.    {rlinm|rlwinm} %0,%1,0,0xffff"
  279.   [(set_attr "type" "load,*")])
  280.  
  281. (define_insn ""
  282.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  283.     (compare:CC (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r"))
  284.             (const_int 0)))
  285.    (clobber (match_scratch:SI 2 "=r"))]
  286.   ""
  287.   "{andil.|andi.} %2,%1,0xffff"
  288.   [(set_attr "type" "compare")])
  289.  
  290. (define_insn ""
  291.   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
  292.     (compare:CC (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r"))
  293.             (const_int 0)))
  294.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  295.     (zero_extend:SI (match_dup 1)))]
  296.   ""
  297.   "{andil.|andi.} %0,%1,0xffff"
  298.   [(set_attr "type" "compare")])
  299.  
  300. (define_expand "extendhisi2"
  301.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  302.     (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" "")))]
  303.   ""
  304.   "")
  305.  
  306. (define_insn ""
  307.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  308.     (sign_extend:SI (match_operand:HI 1 "reg_or_mem_operand" "m,r")))]
  309.   ""
  310.   "@
  311.    lha%U1%X1 %0,%1
  312.    {exts|extsh} %0,%1"
  313.   [(set_attr "type" "load,*")])
  314.  
  315. (define_insn ""
  316.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  317.     (compare:CC (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r"))
  318.             (const_int 0)))
  319.    (clobber (match_scratch:SI 2 "=r"))]
  320.   ""
  321.   "{exts.|extsh.} %2,%1"
  322.   [(set_attr "type" "compare")])
  323.  
  324. (define_insn ""
  325.   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
  326.     (compare:CC (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r"))
  327.             (const_int 0)))
  328.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  329.     (sign_extend:SI (match_dup 1)))]
  330.   ""
  331.   "{exts.|extsh.} %0,%1"
  332.   [(set_attr "type" "compare")])
  333.  
  334. ;; Fixed-point arithmetic insns.
  335. (define_insn "addsi3"
  336.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  337.     (plus:SI (match_operand:SI 1 "gpc_reg_operand" "%r,b")
  338.          (match_operand:SI 2 "add_operand" "rI,J")))]
  339.   ""
  340.   "@
  341.    {a%I2|add%I2c} %0,%1,%2
  342.    {cau|addis} %0,%1,%u2")
  343.  
  344. (define_insn ""
  345.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  346.     (compare:CC (plus:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  347.                  (match_operand:SI 2 "reg_or_short_operand" "rI"))
  348.             (const_int 0)))
  349.    (clobber (match_scratch:SI 3 "=r"))]
  350.   ""
  351.   "{a%I2.|add%I2c.} %3,%1,%2"
  352.   [(set_attr "type" "compare")])
  353.    
  354. (define_insn ""
  355.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  356.     (compare:CC (plus:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  357.                  (match_operand:SI 2 "reg_or_short_operand" "rI"))
  358.             (const_int 0)))
  359.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  360.     (plus:SI (match_dup 1) (match_dup 2)))]
  361.   ""
  362.   "{a%I2.|add%I2c.} %0,%1,%2"
  363.   [(set_attr "type" "compare")])
  364.    
  365. ;; Split an add that we can't do in one insn into two insns, each of which
  366. ;; does one 16-bit part.  This is used by combine.  Note that the low-order
  367. ;; add should be last in case the result gets used in an address.
  368.  
  369. (define_split
  370.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  371.     (plus:SI (match_operand:SI 1 "gpc_reg_operand" "")
  372.          (match_operand:SI 2 "non_add_cint_operand" "")))]
  373.   ""
  374.   [(set (match_dup 0) (plus:SI (match_dup 1) (match_dup 3)))
  375.    (set (match_dup 0) (plus:SI (match_dup 0) (match_dup 4)))]
  376. "
  377. {
  378.   int low = INTVAL (operands[2]) & 0xffff;
  379.   int high = (unsigned) INTVAL (operands[2]) >> 16;
  380.  
  381.   if (low & 0x8000)
  382.     high++, low |= 0xffff0000;
  383.  
  384.   operands[3] = gen_rtx (CONST_INT, VOIDmode, high << 16);
  385.   operands[4] = gen_rtx (CONST_INT, VOIDmode, low);
  386. }")
  387.  
  388. (define_expand "one_cmplsi2"
  389.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  390.     (not:SI (match_operand:SI 1 "gpc_reg_operand" "r")))]
  391.   ""
  392.   "")
  393.  
  394. (define_insn ""
  395.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  396.     (not:SI (match_operand:SI 1 "gpc_reg_operand" "r")))]
  397.   "TARGET_POWER"
  398.   "{sfi|subfic} %0,%1,-1")
  399.  
  400. (define_insn ""
  401.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  402.     (not:SI (match_operand:SI 1 "gpc_reg_operand" "r")))]
  403.   "! TARGET_POWER"
  404.   "nor %0,%1,%1")
  405.  
  406. (define_insn ""
  407.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  408.     (compare:CC (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  409.             (const_int 0)))
  410.    (clobber (match_scratch:SI 2 "=r"))]
  411.   ""
  412.   "nor. %2,%1,%1"
  413.   [(set_attr "type" "compare")])
  414.  
  415. (define_insn ""
  416.   [(set (match_operand:CC 2 "cc_reg_operand" "=-x")
  417.     (compare:CC (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  418.             (const_int 0)))
  419.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  420.     (not:SI (match_dup 1)))]
  421.   ""
  422.   "nor. %0,%2,%1"
  423.   [(set_attr "type" "compare")])
  424.  
  425. (define_insn ""
  426.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  427.     (minus:SI (match_operand:SI 1 "reg_or_short_operand" "rI")
  428.           (match_operand:SI 2 "gpc_reg_operand" "r")))]
  429.   ""
  430.   "{sf%I1|subf%I1c} %0,%2,%1")
  431.  
  432. (define_insn ""
  433.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  434.     (compare:CC (minus:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  435.                   (match_operand:SI 2 "gpc_reg_operand" "r"))
  436.             (const_int 0)))
  437.    (clobber (match_scratch:SI 3 "=r"))]
  438.   ""
  439.   "{sf.|subfc.} %3,%2,%1"
  440.   [(set_attr "type" "compare")])
  441.  
  442. (define_insn ""
  443.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  444.     (compare:CC (minus:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  445.                   (match_operand:SI 2 "gpc_reg_operand" "r"))
  446.             (const_int 0)))
  447.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  448.     (minus:SI (match_dup 1) (match_dup 2)))]
  449.   ""
  450.   "{sf.|subfc.} %0,%2,%1"
  451.   [(set_attr "type" "compare")])
  452.  
  453. (define_expand "subsi3"
  454.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  455.     (minus:SI (match_operand:SI 1 "reg_or_short_operand" "")
  456.           (match_operand:SI 2 "reg_or_cint_operand" "")))]
  457.   ""
  458.   "
  459. {
  460.   if (GET_CODE (operands[2]) == CONST_INT)
  461.     {
  462.       emit_insn (gen_addsi3 (operands[0], operands[1],
  463.                  negate_rtx (SImode, operands[2])));
  464.       DONE;
  465.     }
  466. }")
  467.  
  468. ;; For SMIN, SMAX, UMIN, and UMAX, we use DEFINE_EXPAND's that involve a doz[i]
  469. ;; instruction and some auxiliary computations.  Then we just have a single
  470. ;; DEFINE_INSN for doz[i] and the define_splits to make them if made by
  471. ;; combine.
  472.  
  473. (define_expand "sminsi3"
  474.   [(set (match_dup 3)
  475.     (if_then_else:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
  476.                 (match_operand:SI 2 "reg_or_short_operand" ""))
  477.              (const_int 0)
  478.              (minus:SI (match_dup 2) (match_dup 1))))
  479.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  480.     (minus:SI (match_dup 2) (match_dup 3)))]
  481.   "TARGET_POWER"
  482.   "
  483. { operands[3] = gen_reg_rtx (SImode); }")
  484.  
  485. (define_split
  486.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  487.     (smin:SI (match_operand:SI 1 "gpc_reg_operand" "")
  488.          (match_operand:SI 2 "reg_or_short_operand" "")))
  489.    (clobber (match_operand:SI 3 "gpc_reg_operand" ""))]
  490.   "TARGET_POWER"
  491.   [(set (match_dup 3)
  492.     (if_then_else:SI (gt:SI (match_dup 1) (match_dup 2))
  493.              (const_int 0)
  494.              (minus:SI (match_dup 2) (match_dup 1))))
  495.    (set (match_dup 0) (minus:SI (match_dup 2) (match_dup 3)))]
  496.   "")
  497.  
  498. (define_expand "smaxsi3"
  499.   [(set (match_dup 3)
  500.     (if_then_else:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
  501.                 (match_operand:SI 2 "reg_or_short_operand" ""))
  502.              (const_int 0)
  503.              (minus:SI (match_dup 2) (match_dup 1))))
  504.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  505.     (plus:SI (match_dup 3) (match_dup 1)))]
  506.   "TARGET_POWER"
  507.   "
  508. { operands[3] = gen_reg_rtx (SImode); }")
  509.  
  510. (define_split
  511.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  512.     (smax:SI (match_operand:SI 1 "gpc_reg_operand" "")
  513.          (match_operand:SI 2 "reg_or_short_operand" "")))
  514.    (clobber (match_operand:SI 3 "gpc_reg_operand" ""))]
  515.   "TARGET_POWER"
  516.   [(set (match_dup 3)
  517.     (if_then_else:SI (gt:SI (match_dup 1) (match_dup 2))
  518.              (const_int 0)
  519.              (minus:SI (match_dup 2) (match_dup 1))))
  520.    (set (match_dup 0) (plus:SI (match_dup 3) (match_dup 1)))]
  521.   "")
  522.  
  523. (define_expand "uminsi3"
  524.   [(set (match_dup 3) (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
  525.                   (const_int -2147483648)))
  526.    (set (match_dup 4) (xor:SI (match_operand:SI 2 "gpc_reg_operand" "")
  527.                   (const_int -2147483648)))
  528.    (set (match_dup 3) (if_then_else:SI (gt (match_dup 3) (match_dup 4))
  529.                        (const_int 0)
  530.                        (minus:SI (match_dup 4) (match_dup 3))))
  531.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  532.     (minus:SI (match_dup 2) (match_dup 3)))]
  533.   "TARGET_POWER"
  534.   "
  535. { operands[3] = gen_reg_rtx (SImode);  operands[4] = gen_reg_rtx (SImode); }")
  536.  
  537. (define_expand "umaxsi3"
  538.   [(set (match_dup 3) (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
  539.                   (const_int -2147483648)))
  540.    (set (match_dup 4) (xor:SI (match_operand:SI 2 "gpc_reg_operand" "")
  541.                   (const_int -2147483648)))
  542.    (set (match_dup 3) (if_then_else:SI (gt (match_dup 3) (match_dup 4))
  543.                        (const_int 0)
  544.                        (minus:SI (match_dup 4) (match_dup 3))))
  545.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  546.     (plus:SI (match_dup 3) (match_dup 1)))]
  547.   "TARGET_POWER"
  548.   "
  549. { operands[3] = gen_reg_rtx (SImode);  operands[4] = gen_reg_rtx (SImode); }")
  550.  
  551. (define_insn ""
  552.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  553.     (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "r")
  554.                  (match_operand:SI 2 "reg_or_short_operand" "rI"))
  555.              (const_int 0)
  556.              (minus:SI (match_dup 2) (match_dup 1))))]
  557.   "TARGET_POWER"
  558.   "doz%I2 %0,%1,%2")
  559.  
  560. (define_insn ""
  561.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  562.     (compare:CC
  563.      (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "r")
  564.                   (match_operand:SI 2 "reg_or_short_operand" "rI"))
  565.               (const_int 0)
  566.               (minus:SI (match_dup 2) (match_dup 1)))
  567.      (const_int 0)))
  568.    (clobber (match_scratch:SI 3 "=r"))]
  569.   "TARGET_POWER"
  570.   "doz%I2. %3,%1,%2"
  571.   [(set_attr "type" "delayed_compare")])
  572.  
  573. (define_insn ""
  574.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  575.     (compare:CC
  576.      (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "r")
  577.                   (match_operand:SI 2 "reg_or_short_operand" "rI"))
  578.               (const_int 0)
  579.               (minus:SI (match_dup 2) (match_dup 1)))
  580.      (const_int 0)))
  581.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  582.     (if_then_else:SI (gt (match_dup 1) (match_dup 2))
  583.              (const_int 0)
  584.              (minus:SI (match_dup 2) (match_dup 1))))]
  585.   "TARGET_POWER"
  586.   "doz%I2. %0,%1,%2"
  587.   [(set_attr "type" "delayed_compare")])
  588.  
  589. ;; We don't need abs with condition code because such comparisons should
  590. ;; never be done.
  591. (define_insn "abssi2"
  592.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  593.     (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))]
  594.   "TARGET_POWER"
  595.   "abs %0,%1")
  596.  
  597. (define_insn ""
  598.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  599.     (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r"))))]
  600.   "TARGET_POWER"
  601.   "nabs %0,%1")
  602.  
  603. (define_insn "negsi2"
  604.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  605.     (neg:SI (match_operand:SI 1 "gpc_reg_operand" "r")))]
  606.   ""
  607.   "neg %0,%1")
  608.  
  609. (define_insn ""
  610.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  611.     (compare:CC (neg:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  612.             (const_int 0)))
  613.    (clobber (match_scratch:SI 2 "=r"))]
  614.   ""
  615.   "neg. %2,%1"
  616.   [(set_attr "type" "compare")])
  617.  
  618. (define_insn ""
  619.   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
  620.     (compare:CC (neg:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  621.             (const_int 0)))
  622.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  623.     (neg:SI (match_dup 1)))]
  624.   ""
  625.   "neg. %0,%1"
  626.   [(set_attr "type" "compare")])
  627.  
  628. (define_insn "ffssi2"
  629.   [(set (match_operand:SI 0 "register_operand" "=&r")
  630.     (ffs:SI (match_operand:SI 1 "register_operand" "r")))]
  631.   ""
  632.   "neg %0,%1\;and %0,%0,%1\;{cntlz|cntlzw} %0,%0\;{sfi|subfic} %0,%0,32"
  633.   [(set_attr "length" "16")])
  634.  
  635. (define_expand "mulsi3"
  636.   [(use (match_operand:SI 0 "gpc_reg_operand" ""))
  637.    (use (match_operand:SI 1 "gpc_reg_operand" ""))
  638.    (use (match_operand:SI 2 "reg_or_short_operand" ""))]
  639.   ""
  640.   "
  641. {
  642.   if (TARGET_POWER)
  643.     emit_insn (gen_mulsi3_mq (operands[0], operands[1], operands[2]));
  644.   else
  645.     emit_insn (gen_mulsi3_no_mq (operands[0], operands[1], operands[2]));
  646.   DONE;
  647. }")
  648.  
  649. (define_insn "mulsi3_mq"
  650.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  651.     (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
  652.          (match_operand:SI 2 "reg_or_short_operand" "r,I")))
  653.    (clobber (match_scratch:SI 3 "=q,q"))]
  654.   "TARGET_POWER"
  655.   "@
  656.    {muls|mullw} %0,%1,%2
  657.    {muli|mulli} %0,%1,%2"
  658.    [(set_attr "type" "imul")])
  659.  
  660. (define_insn "mulsi3_no_mq"
  661.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  662.     (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
  663.          (match_operand:SI 2 "reg_or_short_operand" "r,I")))]
  664.   "! TARGET_POWER"
  665.   "@
  666.    mullw %0,%1,%2
  667.    mulli %0,%1,%2"
  668.    [(set_attr "type" "imul")])
  669.  
  670. (define_insn ""
  671.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  672.     (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  673.                  (match_operand:SI 2 "gpc_reg_operand" "r"))
  674.             (const_int 0)))
  675.    (clobber (match_scratch:SI 3 "=r"))
  676.    (clobber (match_scratch:SI 4 "=q"))]
  677.   "TARGET_POWER"
  678.   "{muls.|mullw.} %3,%1,%2"
  679.   [(set_attr "type" "delayed_compare")])
  680.  
  681. (define_insn ""
  682.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  683.     (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  684.                  (match_operand:SI 2 "gpc_reg_operand" "r"))
  685.             (const_int 0)))
  686.    (clobber (match_scratch:SI 3 "=r"))]
  687.   "! TARGET_POWER"
  688.   "mullw. %3,%1,%2"
  689.   [(set_attr "type" "delayed_compare")])
  690.  
  691. (define_insn ""
  692.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  693.     (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  694.                  (match_operand:SI 2 "gpc_reg_operand" "r"))
  695.             (const_int 0)))
  696.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  697.     (mult:SI (match_dup 1) (match_dup 2)))
  698.    (clobber (match_scratch:SI 4 "=q"))]
  699.   "TARGET_POWER"
  700.   "{muls.|mullw.} %0,%1,%2"
  701.   [(set_attr "type" "delayed_compare")])
  702.  
  703. (define_insn ""
  704.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  705.     (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  706.                  (match_operand:SI 2 "gpc_reg_operand" "r"))
  707.             (const_int 0)))
  708.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  709.     (mult:SI (match_dup 1) (match_dup 2)))]
  710.   "! TARGET_POWER"
  711.   "mullw. %0,%1,%2"
  712.   [(set_attr "type" "delayed_compare")])
  713.  
  714. ;; Operand 1 is divided by operand 2; quotient goes to operand
  715. ;; 0 and remainder to operand 3.
  716. ;; ??? At some point, see what, if anything, we can do about if (x % y == 0).
  717.  
  718. (define_insn "divmodsi4"
  719.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  720.     (div:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  721.         (match_operand:SI 2 "gpc_reg_operand" "r")))
  722.    (set (match_operand:SI 3 "gpc_reg_operand" "=q")
  723.     (mod:SI (match_dup 1) (match_dup 2)))]
  724.   "TARGET_POWER"
  725.   "divs %0,%1,%2"
  726.   [(set_attr "type" "idiv")])
  727.  
  728. (define_insn ""
  729.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  730.         (div:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  731.                 (match_operand:SI 2 "gpc_reg_operand" "r")))]
  732.   "TARGET_POWERPC"
  733.   "divw %0, %1, %2"
  734.   [(set_attr "type" "idiv")])
  735.  
  736. (define_insn "udivsi3"
  737.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  738.         (udiv:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  739.                  (match_operand:SI 2 "gpc_reg_operand" "r")))]
  740.   "TARGET_POWERPC"
  741.   "divwu %0, %1, %2"
  742.   [(set_attr "type" "idiv")])
  743.  
  744. ;; For powers of two we can do srai/aze for divide and then adjust for
  745. ;; modulus.  If it isn't a power of two, FAIL on POWER so divmodsi4 will be
  746. ;; used; for PowerPC, force operands into register and do a normal divide.
  747. (define_expand "divsi3"
  748.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  749.     (div:SI (match_operand:SI 1 "gpc_reg_operand" "")
  750.         (match_operand:SI 2 "reg_or_cint_operand" "")))]
  751.   ""
  752.   "
  753. {
  754.   if (GET_CODE (operands[2]) == CONST_INT
  755.       && exact_log2 (INTVAL (operands[2])) >= 0)
  756.     ;
  757.  
  758.   else if (! TARGET_POWERPC)
  759.     FAIL;
  760.  
  761.   operands[2] = force_reg (SImode, operands[2]);
  762. }")
  763.  
  764. (define_expand "modsi3"
  765.   [(use (match_operand:SI 0 "gpc_reg_operand" ""))
  766.    (use (match_operand:SI 1 "gpc_reg_operand" ""))
  767.    (use (match_operand:SI 2 "const_int_operand" ""))]
  768.   ""
  769.   "
  770. {
  771.   int i = exact_log2 (INTVAL (operands[2]));
  772.   rtx temp1;
  773.   rtx temp2;
  774.  
  775.   if (i < 0)
  776.     FAIL;
  777.  
  778.   temp1 = gen_reg_rtx (SImode);
  779.   temp2 = gen_reg_rtx (SImode);
  780.  
  781.   emit_insn (gen_divsi3 (temp1, operands[1], operands[2]));
  782.   emit_insn (gen_ashlsi3 (temp2, temp1, GEN_INT (i)));
  783.   emit_insn (gen_subsi3 (operands[0], operands[1], temp2));
  784.   DONE;
  785.  
  786. }")
  787.  
  788. (define_insn ""
  789.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  790.     (div:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  791.         (match_operand:SI 2 "const_int_operand" "N")))]
  792.   "exact_log2 (INTVAL (operands[2])) >= 0"
  793.   "{srai|srawi} %0,%1,%p2\;{aze|addze} %0,%0"
  794.   [(set_attr "length" "8")])
  795.  
  796. (define_insn ""
  797.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  798.     (div:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  799.         (match_operand:SI 2 "const_int_operand" "N")))
  800.    (clobber (match_scratch:SI 3 "=r"))]
  801.   "exact_log2 (INTVAL (operands[2])) >= 0"
  802.   "{srai|srawi} %3,%1,%p2\;{aze.|addze.} %3,%3"
  803.   [(set_attr "type" "compare")
  804.    (set_attr "length" "8")])
  805.  
  806. (define_insn ""
  807.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  808.     (div:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  809.         (match_operand:SI 2 "const_int_operand" "N")))
  810.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  811.     (div:SI (match_dup 1) (match_dup 2)))]
  812.   "exact_log2 (INTVAL (operands[2])) >= 0"
  813.   "{srai|srawi} %0,%1,%p2\;{aze.|addze.} %0,%0"
  814.   [(set_attr "type" "compare")
  815.    (set_attr "length" "8")])
  816.  
  817. (define_insn ""
  818.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  819.     (udiv:SI
  820.      (plus:DI (lshift:DI
  821.            (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r"))
  822.            (const_int 32))
  823.           (zero_extend:DI (match_operand:SI 4 "register_operand" "2")))
  824.      (match_operand:SI 3 "gpc_reg_operand" "r")))
  825.    (set (match_operand:SI 2 "register_operand" "=*q")
  826.     (umod:SI
  827.      (plus:DI (lshift:DI
  828.            (zero_extend:DI (match_dup 1)) (const_int 32))
  829.           (zero_extend:DI (match_dup 4)))
  830.      (match_dup 3)))]
  831.   
  832.   "TARGET_POWER"
  833.   "div %0,%1,%3"
  834.   [(set_attr "type" "idiv")])
  835.  
  836. ;; To do unsigned divide we handle the cases of the divisor looking like a
  837. ;; negative number.  If it is a constant that is less than 2**31, we don't
  838. ;; have to worry about the branches.  So make a few subroutines here.
  839. ;;
  840. ;; First comes the normal case.
  841. (define_expand "udivmodsi4_normal"
  842.   [(set (match_dup 4) (const_int 0))
  843.    (parallel [(set (match_operand:SI 0 "" "")
  844.            (udiv:SI (plus:DI (lshift:DI (zero_extend:DI (match_dup 4))
  845.                         (const_int 32))
  846.                      (zero_extend:DI (match_operand:SI 1 "" "")))
  847.                 (match_operand:SI 2 "" "")))
  848.           (set (match_operand:SI 3 "" "")
  849.            (umod:SI (plus:DI (lshift:DI (zero_extend:DI (match_dup 4))
  850.                         (const_int 32))
  851.                      (zero_extend:DI (match_dup 1)))
  852.                 (match_dup 2)))])]
  853.   "TARGET_POWER"
  854.   "
  855. { operands[4] = gen_reg_rtx (SImode); }")
  856.  
  857. ;; This handles the branches.
  858. (define_expand "udivmodsi4_tests"
  859.   [(set (match_operand:SI 0 "" "") (const_int 0))
  860.    (set (match_operand:SI 3 "" "") (match_operand:SI 1 "" ""))
  861.    (set (match_dup 5) (compare:CCUNS (match_dup 1) (match_operand:SI 2 "" "")))
  862.    (set (pc) (if_then_else (ltu (match_dup 5) (const_int 0))
  863.                (label_ref (match_operand:SI 4 "" "")) (pc)))
  864.    (set (match_dup 0) (const_int 1))
  865.    (set (match_dup 3) (minus:SI (match_dup 1) (match_dup 2)))
  866.    (set (match_dup 6) (compare:CC (match_dup 2) (const_int 0)))
  867.    (set (pc) (if_then_else (lt (match_dup 6) (const_int 0))
  868.                (label_ref (match_dup 4)) (pc)))]
  869.   "TARGET_POWER"
  870.   "
  871. { operands[5] = gen_reg_rtx (CCUNSmode);
  872.   operands[6] = gen_reg_rtx (CCmode);
  873. }")
  874.  
  875. (define_expand "udivmodsi4"
  876.   [(parallel [(set (match_operand:SI 0 "gpc_reg_operand" "")
  877.            (udiv:SI (match_operand:SI 1 "gpc_reg_operand" "")
  878.                 (match_operand:SI 2 "reg_or_cint_operand" "")))
  879.           (set (match_operand:SI 3 "gpc_reg_operand" "")
  880.            (umod:SI (match_dup 1) (match_dup 2)))])]
  881.   "TARGET_POWER"
  882.   "
  883. {
  884.   rtx label = 0;
  885.  
  886.   if (GET_CODE (operands[2]) != CONST_INT || INTVAL (operands[2]) < 0)
  887.     {
  888.       operands[2] = force_reg (SImode, operands[2]);
  889.       label = gen_label_rtx ();
  890.       emit (gen_udivmodsi4_tests (operands[0], operands[1], operands[2],
  891.                   operands[3], label));
  892.     }
  893.   else
  894.     operands[2] = force_reg (SImode, operands[2]);
  895.  
  896.   emit (gen_udivmodsi4_normal (operands[0], operands[1], operands[2],
  897.                    operands[3]));
  898.   if (label)
  899.     emit_label (label);
  900.  
  901.   DONE;
  902. }")
  903.     
  904. (define_insn "andsi3"
  905.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
  906.     (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r")
  907.         (match_operand:SI 2 "and_operand" "?r,L,K,J")))
  908.    (clobber (match_scratch:CC 3 "=X,X,x,x"))]
  909.   ""
  910.   "@
  911.    and %0,%1,%2
  912.    {rlinm|rlwinm} %0,%1,0,%m2,%M2
  913.    {andil.|andi.} %0,%1,%b2
  914.    {andiu.|andis.} %0,%1,%u2")
  915.  
  916. (define_insn ""
  917.   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x,x")
  918.     (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r")
  919.                 (match_operand:SI 2 "and_operand" "r,K,J,L"))
  920.             (const_int 0)))
  921.    (clobber (match_scratch:SI 3 "=r,r,r,r"))]
  922.   ""
  923.   "@
  924.    and. %3,%1,%2
  925.    {andil.|andi.} %3,%1,%b2
  926.    {andiu.|andis.} %3,%1,%u2
  927.    {rlinm.|rlwinm.} %3,%1,0,%m2,%M2"
  928.   [(set_attr "type" "compare,compare,compare,delayed_compare")])
  929.  
  930. (define_insn ""
  931.   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,x,x")
  932.     (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r")
  933.                 (match_operand:SI 2 "and_operand" "r,K,J,L"))
  934.             (const_int 0)))
  935.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
  936.     (and:SI (match_dup 1) (match_dup 2)))]
  937.   ""
  938.   "@
  939.    and. %0,%1,%2
  940.    {andil.|andi.} %0,%1,%b2
  941.    {andiu.|andis.} %0,%1,%u2
  942.    {rlinm.|rlwinm.} %0,%1,0,%m2,%M2"
  943.   [(set_attr "type" "compare,compare,compare,delayed_compare")])
  944.  
  945. ;; Take a AND with a constant that cannot be done in a single insn and try to
  946. ;; split it into two insns.  This does not verify that the insns are valid
  947. ;; since this need not be done as combine will do it.
  948.  
  949. (define_split
  950.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  951.     (and:SI (match_operand:SI 1 "gpc_reg_operand" "")
  952.         (match_operand:SI 2 "non_and_cint_operand" "")))]
  953.   ""
  954.   [(set (match_dup 0) (and:SI (match_dup 1) (match_dup 3)))
  955.    (set (match_dup 0) (and:SI (match_dup 0) (match_dup 4)))]
  956.   "
  957. {
  958.   int maskval = INTVAL (operands[2]);
  959.   int i, transitions, last_bit_value;
  960.   int orig = maskval, first_c = maskval, second_c;
  961.  
  962.   /* We know that MASKVAL must have more than 2 bit-transitions.  Start at
  963.      the low-order bit and count for the third transition.  When we get there,
  964.      make a first mask that has everything to the left of that position
  965.      a one.  Then make the second mask to turn off whatever else is needed.  */
  966.  
  967.   for (i = 1, transitions = 0, last_bit_value = maskval & 1; i < 32; i++)
  968.     {
  969.       if (((maskval >>= 1) & 1) != last_bit_value)
  970.     last_bit_value ^= 1, transitions++;
  971.  
  972.       if (transitions > 2)
  973.     {
  974.       first_c |= (~0) << i;
  975.       break;
  976.     }
  977.     }
  978.  
  979.   second_c = orig | ~ first_c;
  980.  
  981.   operands[3] = gen_rtx (CONST_INT, VOIDmode, first_c);
  982.   operands[4] = gen_rtx (CONST_INT, VOIDmode, second_c);
  983. }")
  984.  
  985. (define_insn "iorsi3"
  986.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r")
  987.     (ior:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r")
  988.         (match_operand:SI 2 "logical_operand" "r,K,J")))]
  989.   ""
  990.   "@
  991.    or %0,%1,%2
  992.    {oril|ori} %0,%1,%b2
  993.    {oriu|oris} %0,%1,%u2")
  994.  
  995. (define_insn ""
  996.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  997.     (compare:CC (ior:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  998.                 (match_operand:SI 2 "gpc_reg_operand" "r"))
  999.             (const_int 0)))
  1000.    (clobber (match_scratch:SI 3 "=r"))]
  1001.   ""
  1002.   "or. %3,%1,%2"
  1003.   [(set_attr "type" "compare")])
  1004.  
  1005. (define_insn ""
  1006.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1007.     (compare:CC (ior:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1008.                 (match_operand:SI 2 "gpc_reg_operand" "r"))
  1009.             (const_int 0)))
  1010.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1011.     (ior:SI (match_dup 1) (match_dup 2)))]
  1012.   ""
  1013.   "or. %0,%1,%2"
  1014.   [(set_attr "type" "compare")])
  1015.  
  1016. ;; Split an IOR that we can't do in one insn into two insns, each of which
  1017. ;; does one 16-bit part.  This is used by combine.
  1018.  
  1019. (define_split
  1020.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  1021.     (ior:SI (match_operand:SI 1 "gpc_reg_operand" "")
  1022.         (match_operand:SI 2 "non_logical_cint_operand" "")))]
  1023.   ""
  1024.   [(set (match_dup 0) (ior:SI (match_dup 1) (match_dup 3)))
  1025.    (set (match_dup 0) (ior:SI (match_dup 0) (match_dup 4)))]
  1026. "
  1027. {
  1028.   operands[3] = gen_rtx (CONST_INT, VOIDmode,
  1029.              INTVAL (operands[2]) & 0xffff0000);
  1030.   operands[4] = gen_rtx (CONST_INT, VOIDmode, INTVAL (operands[2]) & 0xffff);
  1031. }")
  1032.  
  1033. (define_insn "xorsi3"
  1034.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r")
  1035.     (xor:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r")
  1036.         (match_operand:SI 2 "logical_operand" "r,K,J")))]
  1037.   ""
  1038.   "@
  1039.    xor %0,%1,%2
  1040.    {xoril|xori} %0,%1,%b2
  1041.    {xoriu|xoris} %0,%1,%u2")
  1042.  
  1043. (define_insn ""
  1044.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1045.     (compare:CC (xor:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1046.                 (match_operand:SI 2 "gpc_reg_operand" "r"))
  1047.             (const_int 0)))
  1048.    (clobber (match_scratch:SI 3 "=r"))]
  1049.   ""
  1050.   "xor. %3,%1,%2"
  1051.   [(set_attr "type" "compare")])
  1052.  
  1053. (define_insn ""
  1054.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1055.     (compare:CC (xor:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1056.                 (match_operand:SI 2 "gpc_reg_operand" "r"))
  1057.             (const_int 0)))
  1058.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1059.     (xor:SI (match_dup 1) (match_dup 2)))]
  1060.   ""
  1061.   "xor. %0,%1,%2"
  1062.   [(set_attr "type" "compare")])
  1063.  
  1064. ;; Split an XOR that we can't do in one insn into two insns, each of which
  1065. ;; does one 16-bit part.  This is used by combine.
  1066.  
  1067. (define_split
  1068.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  1069.     (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
  1070.         (match_operand:SI 2 "non_logical_cint_operand" "")))]
  1071.   ""
  1072.   [(set (match_dup 0) (xor:SI (match_dup 1) (match_dup 3)))
  1073.    (set (match_dup 0) (xor:SI (match_dup 0) (match_dup 4)))]
  1074. "
  1075. {
  1076.   operands[3] = gen_rtx (CONST_INT, VOIDmode,
  1077.              INTVAL (operands[2]) & 0xffff0000);
  1078.   operands[4] = gen_rtx (CONST_INT, VOIDmode, INTVAL (operands[2]) & 0xffff);
  1079. }")
  1080.  
  1081. (define_insn ""
  1082.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1083.     (not:SI (xor:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
  1084.             (match_operand:SI 2 "gpc_reg_operand" "r"))))]
  1085.    ""
  1086.    "eqv %0,%1,%2")
  1087.  
  1088. (define_insn ""
  1089.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1090.     (compare:CC (not:SI (xor:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
  1091.                     (match_operand:SI 2 "gpc_reg_operand" "r")))
  1092.             (const_int 0)))
  1093.    (clobber (match_scratch:SI 3 "=r"))]
  1094.    ""
  1095.    "eqv. %3,%1,%2"
  1096.    [(set_attr "type" "compare")])
  1097.  
  1098. (define_insn ""
  1099.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1100.     (compare:CC (not:SI (xor:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
  1101.                     (match_operand:SI 2 "gpc_reg_operand" "r")))
  1102.             (const_int 0)))
  1103.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1104.     (not:SI (xor:SI (match_dup 1) (match_dup 2))))]
  1105.    ""
  1106.    "eqv. %0,%1,%2"
  1107.    [(set_attr "type" "compare")])
  1108.  
  1109. (define_insn ""
  1110.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1111.     (and:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  1112.         (match_operand:SI 2 "gpc_reg_operand" "r")))]
  1113.   ""
  1114.   "andc %0,%2,%1")
  1115.  
  1116. (define_insn ""
  1117.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1118.     (compare:CC (and:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  1119.                 (match_operand:SI 2 "gpc_reg_operand" "r"))
  1120.             (const_int 0)))
  1121.    (clobber (match_scratch:SI 3 "=r"))]
  1122.   ""
  1123.   "andc. %3,%2,%1"
  1124.   [(set_attr "type" "compare")])
  1125.  
  1126. (define_insn ""
  1127.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1128.     (compare:CC (and:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  1129.                 (match_operand:SI 2 "gpc_reg_operand" "r"))
  1130.             (const_int 0)))
  1131.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1132.     (and:SI (not:SI (match_dup 1)) (match_dup 2)))]
  1133.   ""
  1134.   "andc. %0,%2,%1"
  1135.   [(set_attr "type" "compare")])
  1136.  
  1137. (define_insn ""
  1138.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1139.     (ior:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  1140.         (match_operand:SI 2 "gpc_reg_operand" "r")))]
  1141.   ""
  1142.   "orc %0,%2,%1")
  1143.  
  1144. (define_insn ""
  1145.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1146.     (compare:CC (ior:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  1147.                 (match_operand:SI 2 "gpc_reg_operand" "r"))
  1148.             (const_int 0)))
  1149.    (clobber (match_scratch:SI 3 "=r"))]
  1150.   ""
  1151.   "orc. %3,%2,%1"
  1152.   [(set_attr "type" "compare")])
  1153.  
  1154. (define_insn ""
  1155.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1156.     (compare:CC (ior:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  1157.                 (match_operand:SI 2 "gpc_reg_operand" "r"))
  1158.             (const_int 0)))
  1159.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1160.     (ior:SI (not:SI (match_dup 1)) (match_dup 2)))]
  1161.   ""
  1162.   "orc. %0,%2,%1"
  1163.   [(set_attr "type" "compare")])
  1164.  
  1165. (define_insn ""
  1166.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1167.     (ior:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  1168.         (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))))]
  1169.   ""
  1170.   "nand %0,%1,%2")
  1171.  
  1172. (define_insn ""
  1173.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1174.     (compare:CC (ior:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  1175.                 (not:SI (match_operand:SI 2 "gpc_reg_operand" "r")))
  1176.             (const_int 0)))
  1177.    (clobber (match_scratch:SI 3 "=r"))]
  1178.   ""
  1179.   "nand. %3,%1,%2"
  1180.   [(set_attr "type" "compare")])
  1181.  
  1182. (define_insn ""
  1183.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1184.     (compare:CC (ior:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  1185.                 (not:SI (match_operand:SI 2 "gpc_reg_operand" "r")))
  1186.             (const_int 0)))
  1187.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1188.     (ior:SI (not:SI (match_dup 1)) (not:SI (match_dup 2))))]
  1189.   ""
  1190.   "nand. %0,%1,%2"
  1191.   [(set_attr "type" "compare")])
  1192.  
  1193. (define_insn ""
  1194.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1195.     (and:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  1196.         (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))))]
  1197.   ""
  1198.   "nor %0,%1,%2")
  1199.  
  1200. (define_insn ""
  1201.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1202.     (compare:CC (and:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  1203.                 (not:SI (match_operand:SI 2 "gpc_reg_operand" "r")))
  1204.             (const_int 0)))
  1205.    (clobber (match_scratch:SI 3 "=r"))]
  1206.   ""
  1207.   "nor. %3,%1,%2"
  1208.   [(set_attr "type" "compare")])
  1209.  
  1210. (define_insn ""
  1211.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1212.     (compare:CC (and:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  1213.                 (not:SI (match_operand:SI 2 "gpc_reg_operand" "r")))
  1214.             (const_int 0)))
  1215.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1216.     (and:SI (not:SI (match_dup 1)) (not:SI (match_dup 2))))]
  1217.   ""
  1218.   "nor. %0,%1,%2"
  1219.   [(set_attr "type" "compare")])
  1220.  
  1221. ;; maskir insn.  We need four forms because things might be in arbitrary
  1222. ;; orders.  Don't define forms that only set CR fields because these
  1223. ;; would modify an input register.
  1224.  
  1225. (define_insn ""
  1226.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1227.     (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))
  1228.             (match_operand:SI 1 "gpc_reg_operand" "0"))
  1229.         (and:SI (match_dup 2)
  1230.             (match_operand:SI 3 "gpc_reg_operand" "r"))))]
  1231.   "TARGET_POWER"
  1232.   "maskir %0,%3,%2")
  1233.  
  1234. (define_insn ""
  1235.   [(set (match_operand:SI 0 "register_operand" "=r")
  1236.     (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))
  1237.             (match_operand:SI 1 "gpc_reg_operand" "0"))
  1238.         (and:SI (match_operand:SI 3 "gpc_reg_operand" "r")
  1239.             (match_dup 2))))]
  1240.   "TARGET_POWER"
  1241.   "maskir %0,%3,%2")
  1242.  
  1243. (define_insn ""
  1244.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1245.     (ior:SI (and:SI (match_operand:SI 2 "gpc_reg_operand" "r")
  1246.             (match_operand:SI 3 "gpc_reg_operand" "r"))
  1247.         (and:SI (not:SI (match_dup 2))
  1248.             (match_operand:SI 1 "gpc_reg_operand" "0"))))]
  1249.   "TARGET_POWER"
  1250.   "maskir %0,%3,%2")
  1251.  
  1252. (define_insn ""
  1253.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1254.     (ior:SI (and:SI (match_operand:SI 3 "gpc_reg_operand" "r")
  1255.             (match_operand:SI 2 "gpc_reg_operand" "r"))
  1256.         (and:SI (not:SI (match_dup 2))
  1257.             (match_operand:SI 1 "gpc_reg_operand" "0"))))]
  1258.   "TARGET_POWER"
  1259.   "maskir %0,%3,%2")
  1260.  
  1261. (define_insn ""
  1262.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  1263.     (compare:CC
  1264.      (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))
  1265.              (match_operand:SI 1 "gpc_reg_operand" "0"))
  1266.          (and:SI (match_dup 2)
  1267.              (match_operand:SI 3 "gpc_reg_operand" "r")))
  1268.      (const_int 0)))
  1269.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1270.     (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
  1271.         (and:SI (match_dup 2) (match_dup 3))))]
  1272.   "TARGET_POWER"
  1273.   "maskir. %0,%3,%2"
  1274.   [(set_attr "type" "compare")])
  1275.  
  1276. (define_insn ""
  1277.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  1278.     (compare:CC
  1279.      (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))
  1280.              (match_operand:SI 1 "gpc_reg_operand" "0"))
  1281.          (and:SI (match_operand:SI 3 "gpc_reg_operand" "r")
  1282.              (match_dup 2)))
  1283.      (const_int 0)))
  1284.    (set (match_operand:SI 0 "register_operand" "=r")
  1285.     (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
  1286.         (and:SI (match_dup 3) (match_dup 2))))]
  1287.   "TARGET_POWER"
  1288.   "maskir. %0,%3,%2"
  1289.   [(set_attr "type" "compare")])
  1290.  
  1291. (define_insn ""
  1292.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  1293.     (compare:CC
  1294.      (ior:SI (and:SI (match_operand:SI 2 "gpc_reg_operand" "r")
  1295.              (match_operand:SI 3 "gpc_reg_operand" "r"))
  1296.          (and:SI (not:SI (match_dup 2))
  1297.              (match_operand:SI 1 "gpc_reg_operand" "0")))
  1298.      (const_int 0)))
  1299.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1300.     (ior:SI (and:SI (match_dup 2) (match_dup 3))
  1301.         (and:SI (not:SI (match_dup 2)) (match_dup 1))))]
  1302.   "TARGET_POWER"
  1303.   "maskir. %0,%3,%2"
  1304.   [(set_attr "type" "compare")])
  1305.  
  1306. (define_insn ""
  1307.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  1308.     (compare:CC
  1309.      (ior:SI (and:SI (match_operand:SI 3 "gpc_reg_operand" "r")
  1310.              (match_operand:SI 2 "gpc_reg_operand" "r"))
  1311.          (and:SI (not:SI (match_dup 2))
  1312.              (match_operand:SI 1 "gpc_reg_operand" "0")))
  1313.      (const_int 0)))
  1314.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1315.     (ior:SI (and:SI (match_dup 3) (match_dup 2))
  1316.         (and:SI (not:SI (match_dup 2)) (match_dup 1))))]
  1317.   "TARGET_POWER"
  1318.   "maskir. %0,%3,%2"
  1319.   [(set_attr "type" "compare")])
  1320.  
  1321. ;; Rotate and shift insns, in all their variants.  These support shifts,
  1322. ;; field inserts and extracts, and various combinations thereof.
  1323. (define_insn "insv"
  1324.   [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
  1325.              (match_operand:SI 1 "const_int_operand" "i")
  1326.              (match_operand:SI 2 "const_int_operand" "i"))
  1327.     (match_operand:SI 3 "gpc_reg_operand" "r"))]
  1328.   ""
  1329.   "*
  1330. {
  1331.   int start = INTVAL (operands[2]) & 31;
  1332.   int size = INTVAL (operands[1]) & 31;
  1333.  
  1334.   operands[4] = gen_rtx (CONST_INT, VOIDmode, 32 - start - size);
  1335.   operands[1] = gen_rtx (CONST_INT, VOIDmode, start + size - 1);
  1336.   return \"{rlimi|rlwimi} %0,%3,%4,%h2,%h1\";
  1337. }")
  1338.  
  1339. (define_insn "extzv"
  1340.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1341.     (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1342.              (match_operand:SI 2 "const_int_operand" "i")
  1343.              (match_operand:SI 3 "const_int_operand" "i")))]
  1344.   ""
  1345.   "*
  1346. {
  1347.   int start = INTVAL (operands[3]) & 31;
  1348.   int size = INTVAL (operands[2]) & 31;
  1349.  
  1350.   if (start + size >= 32)
  1351.     operands[3] = const0_rtx;
  1352.   else
  1353.     operands[3] = gen_rtx (CONST_INT, VOIDmode, start + size);
  1354.   return \"{rlinm|rlwinm} %0,%1,%3,%s2,31\";
  1355. }")
  1356.  
  1357. (define_insn ""
  1358.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1359.     (compare:CC (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1360.              (match_operand:SI 2 "const_int_operand" "i")
  1361.              (match_operand:SI 3 "const_int_operand" "i"))
  1362.             (const_int 0)))
  1363.    (clobber (match_scratch:SI 4 "=r"))]
  1364.   ""
  1365.   "*
  1366. {
  1367.   int start = INTVAL (operands[3]) & 31;
  1368.   int size = INTVAL (operands[2]) & 31;
  1369.  
  1370.   /* If the bitfield being tested fits in the upper or lower half of a
  1371.      word, it is possible to use andiu. or andil. to test it.  This is
  1372.      useful because the condition register set-use delay is smaller for
  1373.      andi[ul]. than for rlinm.  This doesn't work when the starting bit
  1374.      position is 0 because the LT and GT bits may be set wrong.  */
  1375.  
  1376.   if ((start > 0 && start + size <= 16) || start >= 16)
  1377.     {
  1378.       operands[3] = gen_rtx (CONST_INT, VOIDmode,
  1379.                  ((1 << (16 - (start & 15)))
  1380.                   - (1 << (16 - (start & 15) - size))));
  1381.       if (start < 16)
  1382.     return \"{andiu.|andis.} %4,%1,%3\";
  1383.       else
  1384.     return \"{andil.|andi.} %4,%1,%3\";
  1385.     }
  1386.   
  1387.   if (start + size >= 32)
  1388.     operands[3] = const0_rtx;
  1389.   else
  1390.     operands[3] = gen_rtx (CONST_INT, VOIDmode, start + size);
  1391.   return \"{rlinm.|rlwinm.} %4,%1,%3,%s2,31\";
  1392. }"
  1393.   [(set_attr "type" "compare")])
  1394.  
  1395. (define_insn ""
  1396.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  1397.     (compare:CC (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1398.              (match_operand:SI 2 "const_int_operand" "i")
  1399.              (match_operand:SI 3 "const_int_operand" "i"))
  1400.             (const_int 0)))
  1401.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1402.     (zero_extract:SI (match_dup 1) (match_dup 2) (match_dup 3)))]
  1403.   ""
  1404.   "*
  1405. {
  1406.   int start = INTVAL (operands[3]) & 31;
  1407.   int size = INTVAL (operands[2]) & 31;
  1408.  
  1409.   if (start >= 16 && start + size == 32)
  1410.     {
  1411.       operands[3] = gen_rtx (CONST_INT, VOIDmode, (1 << (32 - start)) - 1);
  1412.       return \"{andil.|andi.} %0,%1,%3\";
  1413.     }
  1414.   
  1415.   if (start + size >= 32)
  1416.     operands[3] = const0_rtx;
  1417.   else
  1418.     operands[3] = gen_rtx (CONST_INT, VOIDmode, start + size);
  1419.   return \"{rlinm.|rlwinm.} %0,%1,%3,%s2,31\";
  1420. }"
  1421.   [(set_attr "type" "delayed_compare")])
  1422.  
  1423. (define_insn "rotlsi3"
  1424.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1425.     (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1426.            (match_operand:SI 2 "reg_or_cint_operand" "ri")))]
  1427.   ""
  1428.   "{rl%I2nm|rlw%I2nm} %0,%1,%h2,0xffffffff")
  1429.  
  1430. (define_insn ""
  1431.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1432.     (compare:CC (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1433.                    (match_operand:SI 2 "reg_or_cint_operand" "ri"))
  1434.             (const_int 0)))
  1435.    (clobber (match_scratch:SI 3 "=r"))]
  1436.   ""
  1437.   "{rl%I2nm.|rlw%I2nm.} %3,%1,%h2,0xffffffff"
  1438.   [(set_attr "type" "delayed_compare")])
  1439.  
  1440. (define_insn ""
  1441.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1442.     (compare:CC (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1443.                    (match_operand:SI 2 "reg_or_cint_operand" "ri"))
  1444.             (const_int 0)))
  1445.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1446.     (rotate:SI (match_dup 1) (match_dup 2)))]
  1447.   ""
  1448.   "{rl%I2nm.|rlw%I2nm.} %0,%1,%h2,0xffffffff"
  1449.   [(set_attr "type" "delayed_compare")])
  1450.  
  1451. (define_insn ""
  1452.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1453.     (and:SI (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1454.                (match_operand:SI 2 "reg_or_cint_operand" "ri"))
  1455.         (match_operand:SI 3 "mask_operand" "L")))]
  1456.   ""
  1457.   "{rl%I2nm|rlw%I2nm} %0,%1,%h2,%m3,%M3")
  1458.  
  1459. (define_insn ""
  1460.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1461.     (compare:CC (and:SI
  1462.              (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1463.                 (match_operand:SI 2 "reg_or_cint_operand" "ri"))
  1464.              (match_operand:SI 3 "mask_operand" "L"))
  1465.             (const_int 0)))
  1466.    (clobber (match_scratch:SI 4 "=r"))]
  1467.   ""
  1468.   "{rl%I2nm.|rlw%I2nm.} %4,%1,%h2,%m3,%M3"
  1469.   [(set_attr "type" "delayed_compare")])
  1470.  
  1471. (define_insn ""
  1472.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  1473.     (compare:CC (and:SI
  1474.              (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1475.                 (match_operand:SI 2 "reg_or_cint_operand" "ri"))
  1476.              (match_operand:SI 3 "mask_operand" "L"))
  1477.             (const_int 0)))
  1478.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1479.     (and:SI (rotate:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
  1480.   ""
  1481.   "{rl%I2nm.|rlw%I2nm.} %0,%1,%h2,%m3,%M3"
  1482.   [(set_attr "type" "delayed_compare")])
  1483.  
  1484. (define_insn ""
  1485.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1486.     (zero_extend:SI
  1487.      (subreg:QI
  1488.       (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1489.              (match_operand:SI 2 "reg_or_cint_operand" "ri")) 0)))]
  1490.   ""
  1491.   "{rl%I2nm|rlw%I2nm} %0,%1,%h2,0xff")
  1492.  
  1493. (define_insn ""
  1494.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1495.     (compare:CC (zero_extend:SI
  1496.              (subreg:QI
  1497.               (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1498.                  (match_operand:SI 2 "reg_or_cint_operand" "ri")) 0))
  1499.             (const_int 0)))
  1500.    (clobber (match_scratch:SI 3 "=r"))]
  1501.   ""
  1502.   "{rl%I2nm.|rlw%I2nm.} %3,%1,%h2,0xff"
  1503.   [(set_attr "type" "delayed_compare")])
  1504.  
  1505. (define_insn ""
  1506.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1507.     (compare:CC (zero_extend:SI
  1508.              (subreg:QI
  1509.               (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1510.                  (match_operand:SI 2 "reg_or_cint_operand" "ri")) 0))
  1511.             (const_int 0)))
  1512.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1513.     (zero_extend:SI (subreg:QI (rotate:SI (match_dup 1) (match_dup 2)) 0)))]
  1514.   ""
  1515.   "{rl%I2nm.|rlw%I2nm.} %0,%1,%h2,0xff"
  1516.   [(set_attr "type" "delayed_compare")])
  1517.  
  1518. (define_insn ""
  1519.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1520.     (zero_extend:SI
  1521.      (subreg:HI
  1522.       (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1523.              (match_operand:SI 2 "reg_or_cint_operand" "ri")) 0)))]
  1524.   ""
  1525.   "{rl%I2nm|rlw%I2nm} %0,%1,%h2,0xffff")
  1526.  
  1527. (define_insn ""
  1528.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1529.     (compare:CC (zero_extend:SI
  1530.              (subreg:HI
  1531.               (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1532.                  (match_operand:SI 2 "reg_or_cint_operand" "ri")) 0))
  1533.             (const_int 0)))
  1534.    (clobber (match_scratch:SI 3 "=r"))]
  1535.   ""
  1536.   "{rl%I2nm.|rlw%I2nm.} %3,%1,%h2,0xffff"
  1537.   [(set_attr "type" "delayed_compare")])
  1538.  
  1539. (define_insn ""
  1540.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1541.     (compare:CC (zero_extend:SI
  1542.              (subreg:HI
  1543.               (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1544.                  (match_operand:SI 2 "reg_or_cint_operand" "ri")) 0))
  1545.             (const_int 0)))
  1546.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1547.     (zero_extend:SI (subreg:HI (rotate:SI (match_dup 1) (match_dup 2)) 0)))]
  1548.   ""
  1549.   "{rl%I2nm.|rlw%I2nm.} %0,%1,%h2,0xffff"
  1550.   [(set_attr "type" "delayed_compare")])
  1551.  
  1552. ;; Note that we use "sle." instead of "sl." so that we can set
  1553. ;; SHIFT_COUNT_TRUNCATED.
  1554.  
  1555. (define_expand "ashlsi3"
  1556.   [(use (match_operand:SI 0 "gpc_reg_operand" ""))
  1557.    (use (match_operand:SI 1 "gpc_reg_operand" ""))
  1558.    (use (match_operand:SI 2 "reg_or_cint_operand" ""))]
  1559.   ""
  1560.   "
  1561. {
  1562.   if (TARGET_POWER)
  1563.     emit_insn (gen_ashlsi3_power (operands[0], operands[1], operands[2]));
  1564.   else
  1565.     emit_insn (gen_ashlsi3_no_power (operands[0], operands[1], operands[2]));
  1566.   DONE;
  1567. }")
  1568.  
  1569. (define_insn "ashlsi3_power"
  1570.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  1571.     (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  1572.            (match_operand:SI 2 "reg_or_cint_operand" "r,i")))
  1573.    (clobber (match_scratch:SI 3 "=q,X"))]
  1574.   "TARGET_POWER"
  1575.   "@
  1576.    sle %0,%1,%2
  1577.    {sli|slwi} %0,%1,%h2"
  1578.   [(set_attr "length" "8")])
  1579.  
  1580. (define_insn "ashlsi3_no_power"
  1581.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1582.     (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1583.            (match_operand:SI 2 "reg_or_cint_operand" "ri")))]
  1584.   "! TARGET_POWER"
  1585.   "slw%I2 %0,%1,%2"
  1586.   [(set_attr "length" "8")])
  1587.  
  1588. (define_insn ""
  1589.   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
  1590.     (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  1591.                    (match_operand:SI 2 "reg_or_cint_operand" "r,i"))
  1592.             (const_int 0)))
  1593.    (clobber (match_scratch:SI 3 "=r,r"))
  1594.    (clobber (match_scratch:SI 4 "=q,X"))]
  1595.   "TARGET_POWER"
  1596.   "@
  1597.    sle. %3,%1,%2
  1598.    {sli.|slwi.} %3,%1,%h2"
  1599.   [(set_attr "type" "delayed_compare")])
  1600.  
  1601. (define_insn ""
  1602.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1603.     (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1604.                    (match_operand:SI 2 "reg_or_cint_operand" "ri"))
  1605.             (const_int 0)))
  1606.    (clobber (match_scratch:SI 3 "=r"))]
  1607.   "TARGET_POWERPC"
  1608.   "slw%I2. %3,%1,%2"
  1609.   [(set_attr "type" "delayed_compare")])
  1610.  
  1611. (define_insn ""
  1612.   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x")
  1613.     (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  1614.                    (match_operand:SI 2 "reg_or_cint_operand" "r,i"))
  1615.             (const_int 0)))
  1616.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  1617.     (ashift:SI (match_dup 1) (match_dup 2)))
  1618.    (clobber (match_scratch:SI 4 "=q,X"))]
  1619.   "TARGET_POWER"
  1620.   "@
  1621.    sle. %0,%1,%2
  1622.    {sli.|slwi.} %0,%1,%h2"
  1623.   [(set_attr "type" "delayed_compare")])
  1624.  
  1625. (define_insn ""
  1626.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1627.     (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1628.                    (match_operand:SI 2 "reg_or_cint_operand" "ri"))
  1629.             (const_int 0)))
  1630.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1631.     (ashift:SI (match_dup 1) (match_dup 2)))]
  1632.   "TARGET_POWERPC"
  1633.   "slw%I2. %0,%1,%2"
  1634.   [(set_attr "type" "delayed_compare")])
  1635.  
  1636. (define_insn ""
  1637.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1638.     (and:SI (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1639.                (match_operand:SI 2 "const_int_operand" "i"))
  1640.         (match_operand:SI 3 "mask_operand" "L")))]
  1641.   "includes_lshift_p (operands[2], operands[3])"
  1642.   "{rlinm|rlwinm} %0,%h1,%h2,%m3,%M3")
  1643.  
  1644. (define_insn ""
  1645.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1646.     (compare:CC
  1647.      (and:SI (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1648.                 (match_operand:SI 2 "const_int_operand" "i"))
  1649.          (match_operand:SI 3 "mask_operand" "L"))
  1650.      (const_int 0)))
  1651.    (clobber (match_scratch:SI 4 "=r"))]
  1652.   "includes_lshift_p (operands[2], operands[3])"
  1653.   "{rlinm.|rlwinm.} %4,%h1,%h2,%m3,%M3"
  1654.   [(set_attr "type" "delayed_compare")])
  1655.  
  1656. (define_insn ""
  1657.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  1658.     (compare:CC
  1659.      (and:SI (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1660.                 (match_operand:SI 2 "const_int_operand" "i"))
  1661.          (match_operand:SI 3 "mask_operand" "L"))
  1662.      (const_int 0)))
  1663.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1664.     (and:SI (ashift:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
  1665.   "includes_lshift_p (operands[2], operands[3])"
  1666.   "{rlinm.|rlwinm.} %0,%h1,%h2,%m3,%M3"
  1667.   [(set_attr "type" "delayed_compare")])
  1668.  
  1669. ;; The AIX assembler mis-handles "sri x,x,0", so write that case as
  1670. ;; "sli x,x,0".
  1671. (define_expand "lshrsi3"
  1672.   [(use (match_operand:SI 0 "gpc_reg_operand" ""))
  1673.    (use (match_operand:SI 1 "gpc_reg_operand" ""))
  1674.    (use (match_operand:SI 2 "reg_or_cint_operand" ""))]
  1675.   ""
  1676.   "
  1677. {
  1678.   if (TARGET_POWER)
  1679.     emit_insn (gen_lshrsi3_power (operands[0], operands[1], operands[2]));
  1680.   else
  1681.     emit_insn (gen_lshrsi3_no_power (operands[0], operands[1], operands[2]));
  1682.   DONE;
  1683. }")
  1684.  
  1685. (define_insn "lshrsi3_power"
  1686.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  1687.     (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  1688.              (match_operand:SI 2 "reg_or_cint_operand" "r,i")))
  1689.    (clobber (match_scratch:SI 3 "=q,X"))]
  1690.   "TARGET_POWER"
  1691.   "@
  1692.   sre %0,%1,%2
  1693.   {s%A2i|s%A2wi} %0,%1,%h2")
  1694.  
  1695. (define_insn "lshrsi3_no_power"
  1696.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1697.     (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1698.              (match_operand:SI 2 "reg_or_cint_operand" "ri")))]
  1699.   "! TARGET_POWER"
  1700.   "srw%I2 %0,%1,%2")
  1701.  
  1702. (define_insn ""
  1703.   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
  1704.     (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  1705.                  (match_operand:SI 2 "reg_or_cint_operand" "r,i"))
  1706.             (const_int 0)))
  1707.    (clobber (match_scratch:SI 3 "=r,r"))
  1708.    (clobber (match_scratch:SI 4 "=q,X"))]
  1709.   "TARGET_POWER"
  1710.   "@
  1711.   sre. %3,%1,%2
  1712.   {s%A2i.|s%A2wi.} %3,%1,%h2"
  1713.   [(set_attr "type" "delayed_compare")])
  1714.  
  1715. (define_insn ""
  1716.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1717.     (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1718.                  (match_operand:SI 2 "reg_or_cint_operand" "ri"))
  1719.             (const_int 0)))
  1720.    (clobber (match_scratch:SI 3 "=r"))]
  1721.   "! TARGET_POWER"
  1722.   "srw%I2. %3,%1,%2"
  1723.   [(set_attr "type" "delayed_compare")])
  1724.  
  1725. (define_insn ""
  1726.   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x")
  1727.     (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  1728.                  (match_operand:SI 2 "reg_or_cint_operand" "r,i"))
  1729.             (const_int 0)))
  1730.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  1731.     (lshiftrt:SI (match_dup 1) (match_dup 2)))
  1732.    (clobber (match_scratch:SI 4 "=q,X"))]
  1733.   "TARGET_POWER"
  1734.   "@
  1735.   sre. %0,%1,%2
  1736.   {s%A2i.|s%A2wi.} %0,%1,%h2"
  1737.   [(set_attr "type" "delayed_compare")])
  1738.  
  1739. (define_insn ""
  1740.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1741.     (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1742.                  (match_operand:SI 2 "reg_or_cint_operand" "ri"))
  1743.             (const_int 0)))
  1744.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1745.     (lshiftrt:SI (match_dup 1) (match_dup 2)))]
  1746.   "! TARGET_POWER"
  1747.   "srw%I2. %0,%1,%2"
  1748.   [(set_attr "type" "delayed_compare")])
  1749.  
  1750. (define_insn ""
  1751.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1752.     (and:SI (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1753.                  (match_operand:SI 2 "const_int_operand" "i"))
  1754.         (match_operand:SI 3 "mask_operand" "L")))]
  1755.   "includes_rshift_p (operands[2], operands[3])"
  1756.   "{rlinm|rlwinm} %0,%1,%s2,%m3,%M3")
  1757.  
  1758. (define_insn ""
  1759.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1760.     (compare:CC
  1761.      (and:SI (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1762.                   (match_operand:SI 2 "const_int_operand" "i"))
  1763.          (match_operand:SI 3 "mask_operand" "L"))
  1764.      (const_int 0)))
  1765.    (clobber (match_scratch:SI 4 "=r"))]
  1766.   "includes_rshift_p (operands[2], operands[3])"
  1767.   "{rlinm.|rlwinm.} %4,%1,%s2,%m3,%M3"
  1768.   [(set_attr "type" "delayed_compare")])
  1769.  
  1770. (define_insn ""
  1771.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  1772.     (compare:CC
  1773.      (and:SI (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1774.                   (match_operand:SI 2 "const_int_operand" "i"))
  1775.          (match_operand:SI 3 "mask_operand" "L"))
  1776.      (const_int 0)))
  1777.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1778.     (and:SI (lshiftrt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
  1779.   "includes_rshift_p (operands[2], operands[3])"
  1780.   "{rlinm.|rlwinm.} %0,%1,%s2,%m3,%M3"
  1781.   [(set_attr "type" "delayed_compare")])
  1782.  
  1783. (define_insn ""
  1784.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1785.     (zero_extend:SI
  1786.      (subreg:QI
  1787.       (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1788.                (match_operand:SI 2 "const_int_operand" "i")) 0)))]
  1789.   "includes_rshift_p (operands[2], gen_rtx (CONST_INT, VOIDmode, 255))"
  1790.   "{rlinm|rlwinm} %0,%1,%s2,0xff")
  1791.  
  1792. (define_insn ""
  1793.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1794.     (compare:CC
  1795.      (zero_extend:SI
  1796.       (subreg:QI
  1797.        (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1798.             (match_operand:SI 2 "const_int_operand" "i")) 0))
  1799.      (const_int 0)))
  1800.    (clobber (match_scratch:SI 3 "=r"))]
  1801.   "includes_rshift_p (operands[2], gen_rtx (CONST_INT, VOIDmode, 255))"
  1802.   "{rlinm.|rlwinm.} %3,%1,%s2,0xff"
  1803.   [(set_attr "type" "delayed_compare")])
  1804.  
  1805. (define_insn ""
  1806.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1807.     (compare:CC
  1808.      (zero_extend:SI
  1809.       (subreg:QI
  1810.        (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1811.             (match_operand:SI 2 "const_int_operand" "i")) 0))
  1812.      (const_int 0)))
  1813.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1814.     (zero_extend:SI (subreg:QI (lshiftrt:SI (match_dup 1) (match_dup 2)) 0)))]
  1815.   "includes_rshift_p (operands[2], gen_rtx (CONST_INT, VOIDmode, 255))"
  1816.   "{rlinm.|rlwinm.} %0,%1,%s2,0xff"
  1817.   [(set_attr "type" "delayed_compare")])
  1818.  
  1819. (define_insn ""
  1820.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1821.     (zero_extend:SI
  1822.      (subreg:HI
  1823.       (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1824.                (match_operand:SI 2 "const_int_operand" "i")) 0)))]
  1825.   "includes_rshift_p (operands[2], gen_rtx (CONST_INT, VOIDmode, 65535))"
  1826.   "{rlinm|rlwinm} %0,%1,%s2,0xffff")
  1827.  
  1828. (define_insn ""
  1829.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1830.     (compare:CC
  1831.      (zero_extend:SI
  1832.       (subreg:HI
  1833.        (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1834.             (match_operand:SI 2 "const_int_operand" "i")) 0))
  1835.      (const_int 0)))
  1836.    (clobber (match_scratch:SI 3 "=r"))]
  1837.   "includes_rshift_p (operands[2], gen_rtx (CONST_INT, VOIDmode, 65535))"
  1838.   "{rlinm.|rlwinm.} %3,%1,%s2,0xffff"
  1839.   [(set_attr "type" "delayed_compare")])
  1840.  
  1841. (define_insn ""
  1842.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1843.     (compare:CC
  1844.      (zero_extend:SI
  1845.       (subreg:HI
  1846.        (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1847.             (match_operand:SI 2 "const_int_operand" "i")) 0))
  1848.      (const_int 0)))
  1849.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1850.     (zero_extend:SI (subreg:HI (lshiftrt:SI (match_dup 1) (match_dup 2)) 0)))]
  1851.   "includes_rshift_p (operands[2], gen_rtx (CONST_INT, VOIDmode, 65535))"
  1852.   "{rlinm.|rlwinm.} %0,%1,%s2,0xffff"
  1853.   [(set_attr "type" "delayed_compare")])
  1854.  
  1855. (define_insn ""
  1856.   [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
  1857.              (const_int 1)
  1858.              (match_operand:SI 1 "gpc_reg_operand" "r"))
  1859.     (ashiftrt:SI (match_operand:SI 2 "gpc_reg_operand" "r")
  1860.              (const_int 31)))]
  1861.   "TARGET_POWER"
  1862.   "rrib %0,%1,%2")
  1863.  
  1864. (define_insn ""
  1865.   [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
  1866.              (const_int 1)
  1867.              (match_operand:SI 1 "gpc_reg_operand" "r"))
  1868.     (lshiftrt:SI (match_operand:SI 2 "gpc_reg_operand" "r")
  1869.              (const_int 31)))]
  1870.   "TARGET_POWER"
  1871.   "rrib %0,%1,%2")
  1872.  
  1873. (define_insn ""
  1874.   [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
  1875.              (const_int 1)
  1876.              (match_operand:SI 1 "gpc_reg_operand" "r"))
  1877.     (zero_extract:SI (match_operand:SI 2 "gpc_reg_operand" "r")
  1878.              (const_int 1)
  1879.              (const_int 0)))]
  1880.   "TARGET_POWER"
  1881.   "rrib %0,%1,%2")
  1882.  
  1883. (define_expand "ashrsi3"
  1884.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  1885.     (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
  1886.              (match_operand:SI 2 "reg_or_cint_operand" "")))]
  1887.   ""
  1888.   "
  1889. {
  1890.   if (TARGET_POWER)
  1891.     emit_insn (gen_ashrsi3_power (operands[0], operands[1], operands[2]));
  1892.   else
  1893.     emit_insn (gen_ashrsi3_no_power (operands[0], operands[1], operands[2]));
  1894.   DONE;
  1895. }")
  1896.  
  1897. (define_insn "ashrsi3_power"
  1898.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  1899.     (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  1900.              (match_operand:SI 2 "reg_or_cint_operand" "r,i")))
  1901.    (clobber (match_scratch:SI 3 "=q,X"))]
  1902.   "TARGET_POWER"
  1903.   "@
  1904.    srea %0,%1,%2
  1905.    {srai|srawi} %0,%1,%h2")
  1906.  
  1907. (define_insn "ashrsi3_no_power"
  1908.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1909.     (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1910.              (match_operand:SI 2 "reg_or_cint_operand" "ri")))]
  1911.   "! TARGET_POWER"
  1912.   "sraw%I2 %0,%1,%2")
  1913.  
  1914. (define_insn ""
  1915.   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
  1916.     (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  1917.                  (match_operand:SI 2 "reg_or_cint_operand" "r,i"))
  1918.             (const_int 0)))
  1919.    (clobber (match_scratch:SI 3 "=r,r"))
  1920.    (clobber (match_scratch:SI 4 "=q,X"))]
  1921.   "TARGET_POWER"
  1922.   "@
  1923.    srea. %3,%1,%2
  1924.    {srai.|srawi.} %3,%1,%h2"
  1925.   [(set_attr "type" "delayed_compare")])
  1926.  
  1927. (define_insn ""
  1928.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1929.     (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1930.                  (match_operand:SI 2 "reg_or_cint_operand" "ri"))
  1931.             (const_int 0)))
  1932.    (clobber (match_scratch:SI 3 "=r"))]
  1933.   "! TARGET_POWER"
  1934.   "sraw%I2. %3,%1,%2"
  1935.   [(set_attr "type" "delayed_compare")])
  1936.  
  1937. (define_insn ""
  1938.   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x")
  1939.     (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  1940.                  (match_operand:SI 2 "reg_or_cint_operand" "r,i"))
  1941.             (const_int 0)))
  1942.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  1943.     (ashiftrt:SI (match_dup 1) (match_dup 2)))
  1944.    (clobber (match_scratch:SI 4 "=q,X"))]
  1945.   "TARGET_POWER"
  1946.   "@
  1947.    srea. %0,%1,%2
  1948.    {srai.|srawi.} %0,%1,%h2"
  1949.   [(set_attr "type" "delayed_compare")])
  1950.  
  1951. (define_insn ""
  1952.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1953.     (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1954.                  (match_operand:SI 2 "reg_or_cint_operand" "ri"))
  1955.             (const_int 0)))
  1956.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1957.     (ashiftrt:SI (match_dup 1) (match_dup 2)))]
  1958.   "! TARGET_POWER"
  1959.   "sraw%I2. %0,%1,%2"
  1960.   [(set_attr "type" "delayed_compare")])
  1961.  
  1962. (define_expand "extendqisi2"
  1963.   [(use (match_operand:SI 0 "gpc_reg_operand" ""))
  1964.    (use (match_operand:QI 1 "gpc_reg_operand" ""))]
  1965.   ""
  1966.   "
  1967. {
  1968.   if (TARGET_POWER)
  1969.     emit_insn (gen_extendqisi2_power (operands[0], operands[1]));
  1970.   else
  1971.     emit_insn (gen_extendqisi2_no_power (operands[0], operands[1]));
  1972.   DONE;
  1973. }")
  1974.  
  1975. (define_expand "extendqisi2_power"
  1976.   [(parallel [(set (match_dup 2)
  1977.            (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
  1978.                   (const_int 24)))
  1979.           (clobber (scratch:SI))])
  1980.    (parallel [(set (match_operand:SI 0 "gpc_reg_operand" "")
  1981.            (ashiftrt:SI (match_dup 2)
  1982.                 (const_int 24)))
  1983.           (clobber (scratch:SI))])]
  1984.   "TARGET_POWER"
  1985.   "
  1986. { operands[1] = gen_lowpart (SImode, operands[1]);
  1987.   operands[2] = gen_reg_rtx (SImode); }")
  1988.  
  1989. (define_expand "extendqisi2_no_power"
  1990.   [(set (match_dup 2)
  1991.            (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
  1992.                   (const_int 24)))
  1993.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  1994.            (ashiftrt:SI (match_dup 2)
  1995.                 (const_int 24)))]
  1996.   "! TARGET_POWER"
  1997.   "
  1998. { operands[1] = gen_lowpart (SImode, operands[1]);
  1999.   operands[2] = gen_reg_rtx (SImode); }")
  2000.  
  2001. (define_expand "extendqihi2"
  2002.   [(use (match_operand:HI 0 "gpc_reg_operand" ""))
  2003.    (use (match_operand:QI 1 "gpc_reg_operand" ""))]
  2004.   ""
  2005.   "
  2006. {
  2007.   if (TARGET_POWER)
  2008.     emit_insn (gen_extendqihi2_power (operands[0], operands[1]));
  2009.   else
  2010.     emit_insn (gen_extendqihi2_no_power (operands[0], operands[1]));
  2011.   DONE;
  2012. }")
  2013.  
  2014. (define_expand "extendqihi2_power"
  2015.   [(parallel [(set (match_dup 2)
  2016.            (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
  2017.                   (const_int 24)))
  2018.           (clobber (scratch:SI))])
  2019.    (parallel [(set (match_operand:HI 0 "gpc_reg_operand" "")
  2020.            (ashiftrt:SI (match_dup 2)
  2021.                 (const_int 24)))
  2022.           (clobber (scratch:SI))])]
  2023.   "TARGET_POWER"
  2024.   "
  2025. { operands[0] = gen_lowpart (SImode, operands[0]);
  2026.   operands[1] = gen_lowpart (SImode, operands[1]);
  2027.   operands[2] = gen_reg_rtx (SImode); }")
  2028.  
  2029. (define_expand "extendqihi2_no_power"
  2030.   [(set (match_dup 2)
  2031.            (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
  2032.                   (const_int 24)))
  2033.    (set (match_operand:HI 0 "gpc_reg_operand" "")
  2034.            (ashiftrt:SI (match_dup 2)
  2035.                 (const_int 24)))]
  2036.   "! TARGET_POWER"
  2037.   "
  2038. { operands[0] = gen_lowpart (SImode, operands[0]);
  2039.   operands[1] = gen_lowpart (SImode, operands[1]);
  2040.   operands[2] = gen_reg_rtx (SImode); }")
  2041.  
  2042. ;; Floating-point insns, excluding normal data motion.
  2043. ;;
  2044. ;; PowerPC has a full set of single-precision floating point instructions.
  2045. ;;
  2046. ;; For the POWER architecture, we pretend that we have both SFmode and
  2047. ;; DFmode insns, while, in fact, all fp insns are actually done in double.
  2048. ;; The only conversions we will do will be when storing to memory.  In that
  2049. ;; case, we will use the "frsp" instruction before storing.
  2050. ;;
  2051. ;; Note that when we store into a single-precision memory location, we need to
  2052. ;; use the frsp insn first.  If the register being stored isn't dead, we
  2053. ;; need a scratch register for the frsp.  But this is difficult when the store
  2054. ;; is done by reload.  It is not incorrect to do the frsp on the register in
  2055. ;; this case, we just lose precision that we would have otherwise gotten but
  2056. ;; is not guaranteed.  Perhaps this should be tightened up at some point.
  2057.  
  2058. (define_insn "extendsfdf2"
  2059.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2060.     (float_extend:DF (match_operand:SF 1 "gpc_reg_operand" "f")))]
  2061.   ""
  2062.   "*
  2063. {
  2064.   if (REGNO (operands[0]) == REGNO (operands[1]))
  2065.     return \"\";
  2066.   else
  2067.     return \"fmr %0,%1\";
  2068. }"
  2069.   [(set_attr "type" "fp")])
  2070.  
  2071. (define_insn "truncdfsf2"
  2072.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2073.     (float_truncate:SF (match_operand:DF 1 "gpc_reg_operand" "f")))]
  2074.   ""
  2075.   "frsp %0,%1"
  2076.   [(set_attr "type" "fp")])
  2077.  
  2078. (define_insn "negsf2"
  2079.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2080.     (neg:SF (match_operand:SF 1 "gpc_reg_operand" "f")))]
  2081.   ""
  2082.   "fneg %0,%1"
  2083.   [(set_attr "type" "fp")])
  2084.  
  2085. (define_insn "abssf2"
  2086.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2087.     (abs:SF (match_operand:SF 1 "gpc_reg_operand" "f")))]
  2088.   ""
  2089.   "fabs %0,%1"
  2090.   [(set_attr "type" "fp")])
  2091.  
  2092. (define_insn ""
  2093.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2094.     (neg:SF (abs:SF (match_operand:SF 1 "gpc_reg_operand" "f"))))]
  2095.   ""
  2096.   "fnabs %0,%1"
  2097.   [(set_attr "type" "fp")])
  2098.  
  2099. (define_expand "addsf3"
  2100.   [(set (match_operand:SF 0 "gpc_reg_operand" "")
  2101.     (plus:SF (match_operand:SF 1 "gpc_reg_operand" "")
  2102.          (match_operand:SF 2 "gpc_reg_operand" "")))]
  2103.   ""
  2104.   "")
  2105.  
  2106. (define_insn ""
  2107.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2108.     (plus:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2109.          (match_operand:SF 2 "gpc_reg_operand" "f")))]
  2110.   "TARGET_POWERPC"
  2111.   "fadds %0,%1,%2"
  2112.   [(set_attr "type" "fp")])
  2113.  
  2114. (define_insn ""
  2115.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2116.     (plus:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2117.          (match_operand:SF 2 "gpc_reg_operand" "f")))]
  2118.   "TARGET_POWER"
  2119.   "{fa|fadd} %0,%1,%2"
  2120.   [(set_attr "type" "fp")])
  2121.  
  2122. (define_expand "subsf3"
  2123.   [(set (match_operand:SF 0 "gpc_reg_operand" "")
  2124.     (minus:SF (match_operand:SF 1 "gpc_reg_operand" "")
  2125.           (match_operand:SF 2 "gpc_reg_operand" "")))]
  2126.   ""
  2127.   "")
  2128.  
  2129. (define_insn ""
  2130.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2131.     (minus:SF (match_operand:SF 1 "gpc_reg_operand" "f")
  2132.           (match_operand:SF 2 "gpc_reg_operand" "f")))]
  2133.   "TARGET_POWERPC"
  2134.   "fsubs %0,%1,%2"
  2135.   [(set_attr "type" "fp")])
  2136.  
  2137. (define_insn ""
  2138.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2139.     (minus:SF (match_operand:SF 1 "gpc_reg_operand" "f")
  2140.           (match_operand:SF 2 "gpc_reg_operand" "f")))]
  2141.   "TARGET_POWER"
  2142.   "{fs|fsub} %0,%1,%2"
  2143.   [(set_attr "type" "fp")])
  2144.  
  2145. (define_expand "mulsf3"
  2146.   [(set (match_operand:SF 0 "gpc_reg_operand" "")
  2147.     (mult:SF (match_operand:SF 1 "gpc_reg_operand" "")
  2148.          (match_operand:SF 2 "gpc_reg_operand" "")))]
  2149.   ""
  2150.   "")
  2151.  
  2152. (define_insn ""
  2153.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2154.     (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2155.          (match_operand:SF 2 "gpc_reg_operand" "f")))]
  2156.   "TARGET_POWERPC"
  2157.   "fmuls %0,%1,%2"
  2158.   [(set_attr "type" "fp")])
  2159.  
  2160. (define_insn ""
  2161.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2162.     (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2163.          (match_operand:SF 2 "gpc_reg_operand" "f")))]
  2164.   "TARGET_POWER"
  2165.   "{fm|fmul} %0,%1,%2"
  2166.   [(set_attr "type" "fp")])
  2167.  
  2168. (define_expand "divsf3"
  2169.   [(set (match_operand:SF 0 "gpc_reg_operand" "")
  2170.     (div:SF (match_operand:SF 1 "gpc_reg_operand" "")
  2171.         (match_operand:SF 2 "gpc_reg_operand" "")))]
  2172.   ""
  2173.   "")
  2174.  
  2175. (define_insn ""
  2176.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2177.     (div:SF (match_operand:SF 1 "gpc_reg_operand" "f")
  2178.         (match_operand:SF 2 "gpc_reg_operand" "f")))]
  2179.   "TARGET_POWERPC"
  2180.   "fdivs %0,%1,%2"
  2181.   [(set_attr "type" "sdiv")])
  2182.  
  2183. (define_insn ""
  2184.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2185.     (div:SF (match_operand:SF 1 "gpc_reg_operand" "f")
  2186.         (match_operand:SF 2 "gpc_reg_operand" "f")))]
  2187.   "TARGET_POWER"
  2188.   "{fd|fdiv} %0,%1,%2"
  2189.   [(set_attr "type" "sdiv")])
  2190.  
  2191. (define_insn ""
  2192.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2193.     (plus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2194.               (match_operand:SF 2 "gpc_reg_operand" "f"))
  2195.          (match_operand:SF 3 "gpc_reg_operand" "f")))]
  2196.   "TARGET_POWERPC"
  2197.   "fmadds %0,%1,%2,%3"
  2198.   [(set_attr "type" "fp")])
  2199.  
  2200. (define_insn ""
  2201.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2202.     (plus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2203.               (match_operand:SF 2 "gpc_reg_operand" "f"))
  2204.          (match_operand:SF 3 "gpc_reg_operand" "f")))]
  2205.   "TARGET_POWER"
  2206.   "{fma|fmadd} %0,%1,%2,%3"
  2207.   [(set_attr "type" "fp")])
  2208.  
  2209. (define_insn ""
  2210.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2211.     (minus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2212.                (match_operand:SF 2 "gpc_reg_operand" "f"))
  2213.           (match_operand:SF 3 "gpc_reg_operand" "f")))]
  2214.   "TARGET_POWERPC"
  2215.   "fmsubs %0,%1,%2,%3"
  2216.   [(set_attr "type" "fp")])
  2217.  
  2218. (define_insn ""
  2219.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2220.     (minus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2221.                (match_operand:SF 2 "gpc_reg_operand" "f"))
  2222.           (match_operand:SF 3 "gpc_reg_operand" "f")))]
  2223.   "TARGET_POWER"
  2224.   "{fms|fmsub} %0,%1,%2,%3"
  2225.   [(set_attr "type" "fp")])
  2226.  
  2227. (define_insn ""
  2228.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2229.     (neg:SF (plus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2230.                   (match_operand:SF 2 "gpc_reg_operand" "f"))
  2231.              (match_operand:SF 3 "gpc_reg_operand" "f"))))]
  2232.   "TARGET_POWERPC"
  2233.   "fnmadds %0,%1,%2,%3"
  2234.   [(set_attr "type" "fp")])
  2235.  
  2236. (define_insn ""
  2237.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2238.     (neg:SF (plus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2239.                   (match_operand:SF 2 "gpc_reg_operand" "f"))
  2240.              (match_operand:SF 3 "gpc_reg_operand" "f"))))]
  2241.   "TARGET_POWER"
  2242.   "{fnma|fnmadd} %0,%1,%2,%3"
  2243.   [(set_attr "type" "fp")])
  2244.  
  2245. (define_insn ""
  2246.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2247.     (neg:SF (minus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2248.                    (match_operand:SF 2 "gpc_reg_operand" "f"))
  2249.               (match_operand:SF 3 "gpc_reg_operand" "f"))))]
  2250.   "TARGET_POWERPC"
  2251.   "fnmsubs %0,%1,%2,%3"
  2252.   [(set_attr "type" "fp")])
  2253.  
  2254. (define_insn ""
  2255.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2256.     (neg:SF (minus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2257.                    (match_operand:SF 2 "gpc_reg_operand" "f"))
  2258.               (match_operand:SF 3 "gpc_reg_operand" "f"))))]
  2259.   "TARGET_POWER"
  2260.   "{fnms|fnmsub} %0,%1,%2,%3"
  2261.   [(set_attr "type" "fp")])
  2262.  
  2263. (define_expand "sqrtsf2"
  2264.   [(set (match_operand:SF 0 "gpc_reg_operand" "")
  2265.     (sqrt:SF (match_operand:SF 1 "gpc_reg_operand" "")))]
  2266.   "TARGET_POWERPCSQR || TARGET_POWER2"
  2267.   "")
  2268.  
  2269. (define_insn ""
  2270.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2271.     (sqrt:SF (match_operand:SF 1 "gpc_reg_operand" "f")))]
  2272.   "TARGET_POWERPCSQR"
  2273.   "fsqrts %0,%1"
  2274.   [(set_attr "type" "ssqrt")])
  2275.  
  2276. (define_insn ""
  2277.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2278.     (sqrt:SF (match_operand:SF 1 "gpc_reg_operand" "f")))]
  2279.   "TARGET_POWER2"
  2280.   "fsqrt %0,%1"
  2281.   [(set_attr "type" "dsqrt")])
  2282.  
  2283. (define_insn "negdf2"
  2284.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2285.     (neg:DF (match_operand:DF 1 "gpc_reg_operand" "f")))]
  2286.   ""
  2287.   "fneg %0,%1"
  2288.   [(set_attr "type" "fp")])
  2289.  
  2290. (define_insn "absdf2"
  2291.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2292.     (abs:DF (match_operand:DF 1 "gpc_reg_operand" "f")))]
  2293.   ""
  2294.   "fabs %0,%1"
  2295.   [(set_attr "type" "fp")])
  2296.  
  2297. (define_insn ""
  2298.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2299.     (neg:DF (abs:DF (match_operand:DF 1 "gpc_reg_operand" "f"))))]
  2300.   ""
  2301.   "fnabs %0,%1"
  2302.   [(set_attr "type" "fp")])
  2303.  
  2304. (define_insn "adddf3"
  2305.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2306.     (plus:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
  2307.          (match_operand:DF 2 "gpc_reg_operand" "f")))]
  2308.   ""
  2309.   "{fa|fadd} %0,%1,%2"
  2310.   [(set_attr "type" "fp")])
  2311.  
  2312. (define_insn "subdf3"
  2313.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2314.     (minus:DF (match_operand:DF 1 "gpc_reg_operand" "f")
  2315.           (match_operand:DF 2 "gpc_reg_operand" "f")))]
  2316.   ""
  2317.   "{fs|fsub} %0,%1,%2"
  2318.   [(set_attr "type" "fp")])
  2319.  
  2320. (define_insn "muldf3"
  2321.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2322.     (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
  2323.          (match_operand:DF 2 "gpc_reg_operand" "f")))]
  2324.   ""
  2325.   "{fm|fmul} %0,%1,%2"
  2326.   [(set_attr "type" "dmul")])
  2327.  
  2328. (define_insn "divdf3"
  2329.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2330.     (div:DF (match_operand:DF 1 "gpc_reg_operand" "f")
  2331.         (match_operand:DF 2 "gpc_reg_operand" "f")))]
  2332.   ""
  2333.   "{fd|fdiv} %0,%1,%2"
  2334.   [(set_attr "type" "ddiv")])
  2335.  
  2336. (define_insn ""
  2337.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2338.     (plus:DF (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
  2339.               (match_operand:DF 2 "gpc_reg_operand" "f"))
  2340.          (match_operand:DF 3 "gpc_reg_operand" "f")))]
  2341.   ""
  2342.   "{fma|fmadd} %0,%1,%2,%3"
  2343.   [(set_attr "type" "dmul")])
  2344.  
  2345. (define_insn ""
  2346.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2347.     (minus:DF (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
  2348.                (match_operand:DF 2 "gpc_reg_operand" "f"))
  2349.           (match_operand:DF 3 "gpc_reg_operand" "f")))]
  2350.   ""
  2351.   "{fms|fmsub} %0,%1,%2,%3"
  2352.   [(set_attr "type" "dmul")])
  2353.  
  2354. (define_insn ""
  2355.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2356.     (neg:DF (plus:DF (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
  2357.                   (match_operand:DF 2 "gpc_reg_operand" "f"))
  2358.              (match_operand:DF 3 "gpc_reg_operand" "f"))))]
  2359.   ""
  2360.   "{fnma|fnmadd} %0,%1,%2,%3"
  2361.   [(set_attr "type" "dmul")])
  2362.  
  2363. (define_insn ""
  2364.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2365.     (neg:DF (minus:DF (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
  2366.                    (match_operand:DF 2 "gpc_reg_operand" "f"))
  2367.               (match_operand:DF 3 "gpc_reg_operand" "f"))))]
  2368.   ""
  2369.   "{fnms|fnmsub} %0,%1,%2,%3"
  2370.   [(set_attr "type" "dmul")])
  2371.  
  2372. (define_insn "sqrtdf2"
  2373.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2374.     (sqrt:DF (match_operand:DF 1 "gpc_reg_operand" "f")))]
  2375.   "TARGET_POWERPCSQR || TARGET_POWER2"
  2376.   "fsqrt %0,%1"
  2377.   [(set_attr "type" "dsqrt")])
  2378.  
  2379. ;; Conversions to and from floating-point.
  2380. (define_expand "floatsidf2"
  2381.   [(set (match_dup 2)
  2382.     (plus:DI (zero_extend:DI
  2383.           (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
  2384.               (match_dup 3)))
  2385.          (match_dup 4)))
  2386.    (set (match_operand:DF 0 "gpc_reg_operand" "")
  2387.     (minus:DF (subreg:DF (match_dup 2) 0)
  2388.           (match_dup 5)))]
  2389.   ""
  2390.   "
  2391. {
  2392. #if HOST_BITS_PER_INT != BITS_PER_WORD
  2393.   /* Maybe someone can figure out how to do this in that case.  I don't
  2394.      want to right now.  */
  2395.   abort ();
  2396. #endif
  2397.  
  2398.   operands[2] = gen_reg_rtx (DImode);
  2399.   operands[3] = gen_rtx (CONST_INT, VOIDmode, 0x80000000);
  2400.   operands[4] = immed_double_const (0, 0x43300000, DImode);
  2401.   operands[5] = force_reg (DFmode, immed_double_const (0x43300000,
  2402.                                0x80000000, DFmode));
  2403. }")
  2404.  
  2405. (define_expand "floatunssidf2"
  2406.   [(set (match_dup 2)
  2407.     (plus:DI (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
  2408.          (match_dup 3)))
  2409.    (set (match_operand:DF 0 "gpc_reg_operand" "")
  2410.     (minus:DF (subreg:DF (match_dup 2) 0)
  2411.           (match_dup 4)))]
  2412.   ""
  2413.   "
  2414. {
  2415. #if HOST_BITS_PER_INT != BITS_PER_WORD
  2416.   /* Maybe someone can figure out how to do this in that case.  I don't
  2417.      want to right now.  */
  2418.   abort ();
  2419. #endif
  2420.  
  2421.   operands[2] = gen_reg_rtx (DImode);
  2422.   operands[3] = immed_double_const (0, 0x43300000, DImode);
  2423.   operands[4] = force_reg (DFmode, immed_double_const (0x43300000, 0, DFmode));
  2424. }")
  2425.  
  2426. ;; For the above two cases, we always split.
  2427. (define_split
  2428.   [(set (match_operand:DI 0 "gpc_reg_operand" "")
  2429.     (plus:DI (zero_extend:DI
  2430.           (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
  2431.               (match_operand:SI 2 "logical_operand" "")))
  2432.          (match_operand:DI 3 "immediate_operand" "")))]
  2433.   "reload_completed && HOST_BITS_PER_INT == BITS_PER_WORD
  2434.    && GET_CODE (operands[3]) == CONST_DOUBLE
  2435.    && CONST_DOUBLE_LOW (operands[3]) == 0"
  2436.   [(set (match_dup 6) (xor:SI (match_dup 1) (match_dup 2)))
  2437.    (set (match_dup 4) (match_dup 5))]
  2438.   "
  2439. { operands[4] = operand_subword (operands[0], 0, 0, DImode);
  2440.   operands[5] = operand_subword (operands[3], 0, 0, DImode);
  2441.   operands[6] = operand_subword (operands[0], 1, 0, DImode);
  2442. }")
  2443.  
  2444. (define_insn ""
  2445.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
  2446.     (plus:DI (zero_extend:DI
  2447.           (xor:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
  2448.               (match_operand:SI 2 "logical_operand" "rKJ")))
  2449.          (match_operand:DI 3 "immediate_operand" "n")))]
  2450.   "HOST_BITS_PER_INT == BITS_PER_WORD
  2451.    && GET_CODE (operands[3]) == CONST_DOUBLE
  2452.    && CONST_DOUBLE_LOW (operands[3]) == 0"
  2453.   "#"
  2454.   [(set_attr "length" "8")])
  2455.   
  2456. (define_split
  2457.   [(set (match_operand:DI 0 "gpc_reg_operand" "=")
  2458.     (plus:DI (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
  2459.          (match_operand:DI 2 "immediate_operand" "")))]
  2460.   "reload_completed && HOST_BITS_PER_INT == BITS_PER_WORD
  2461.    && GET_CODE (operands[2]) == CONST_DOUBLE
  2462.    && CONST_DOUBLE_LOW (operands[2]) == 0"
  2463.   [(set (match_dup 3) (match_dup 4))
  2464.    (set (match_dup 5) (match_dup 1))]
  2465.   "
  2466. { operands[3] = operand_subword (operands[0], 0, 0, DImode);
  2467.   operands[4] = operand_subword (operands[2], 0, 0, DImode);
  2468.   operands[5] = operand_subword (operands[0], 1, 0, DImode);
  2469.  
  2470.   if (rtx_equal_p (operands[1], operands[5]))
  2471.     {
  2472.       emit_move_insn (operands[3], operands[4]);
  2473.       DONE;
  2474.     }
  2475.  
  2476.   if (rtx_equal_p (operands[1], operands[3]))
  2477.     {
  2478.       rtx temp;
  2479.  
  2480.       temp = operands[3]; operands[3] = operands[5]; operands[5] = temp;
  2481.       temp = operands[4]; operands[4] = operands[1]; operands[1] = temp;
  2482.     }
  2483. }")
  2484.  
  2485. (define_insn ""
  2486.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
  2487.     (plus:DI (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r"))
  2488.          (match_operand:DI 2 "immediate_operand" "n")))]
  2489.   "HOST_BITS_PER_INT == BITS_PER_WORD
  2490.    && GET_CODE (operands[2]) == CONST_DOUBLE
  2491.    && CONST_DOUBLE_LOW (operands[2]) == 0"
  2492.   "#"
  2493.   [(set_attr "length" "8")])
  2494.  
  2495. (define_expand "fix_truncdfsi2"
  2496.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  2497.     (fix:SI (match_operand:DF 1 "gpc_reg_operand" "")))]
  2498.   ""
  2499.   "
  2500. {
  2501.   emit_insn (gen_trunc_call (operands[0], operands[1],
  2502.                  gen_rtx (SYMBOL_REF, Pmode, \"itrunc\")));
  2503.   DONE;
  2504. }")
  2505.  
  2506. (define_expand "fixuns_truncdfsi2"
  2507.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  2508.     (unsigned_fix:SI (match_operand:DF 1 "gpc_reg_operand" "")))]
  2509.   ""
  2510.   "
  2511. {
  2512.   emit_insn (gen_trunc_call (operands[0], operands[1],
  2513.                  gen_rtx (SYMBOL_REF, Pmode, \"uitrunc\")));
  2514.   DONE;
  2515. }")
  2516.  
  2517.  
  2518. (define_expand "trunc_call"
  2519.   [(parallel [(set (match_operand:SI 0 "" "")
  2520.            (fix:SI (match_operand:DF 1 "" "")))
  2521.           (use (match_operand:SI 2 "" ""))])]
  2522.   ""
  2523.   "
  2524. {
  2525.   rtx insns = gen_trunc_call_rtl (operands[0], operands[1], operands[2]);
  2526.   rtx first = XVECEXP (insns, 0, 0);
  2527.   rtx last = XVECEXP (insns, 0, XVECLEN (insns, 0) - 1);
  2528.  
  2529.   REG_NOTES (first) = gen_rtx (INSN_LIST, REG_LIBCALL, last,
  2530.                    REG_NOTES (first));
  2531.   REG_NOTES (last) = gen_rtx (INSN_LIST, REG_RETVAL, first, REG_NOTES (last));
  2532.  
  2533.   emit_insn (insns);
  2534.   DONE;
  2535. }")
  2536.  
  2537. (define_expand "trunc_call_rtl"
  2538.   [(set (reg:DF 33) (match_operand:DF 1 "gpc_reg_operand" ""))
  2539.    (use (reg:DF 33))
  2540.    (parallel [(set (reg:SI 3)
  2541.            (call (mem:SI (match_operand 2 "" "")) (const_int 0)))
  2542.           (clobber (scratch:SI))])
  2543.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  2544.     (reg:SI 3))]
  2545.   ""
  2546.   "
  2547. { 
  2548.   rs6000_trunc_used = 1;
  2549. }")
  2550.  
  2551. ;; Define the DImode operations that can be done in a small number
  2552. ;; of instructions.
  2553. (define_expand "adddi3"
  2554.   [(set (match_operand:DI 0 "gpc_reg_operand" "")
  2555.     (plus:DI (match_operand:DI 1 "gpc_reg_operand" "")
  2556.          (match_operand:DI 2 "reg_or_short_operand" "")))]
  2557.   ""
  2558.   "
  2559. {
  2560.   if (! TARGET_POWER
  2561.       && short_cint_operand (operands[2], DImode))
  2562.     FAIL;
  2563. }")
  2564.  
  2565. (define_insn ""
  2566.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
  2567.     (plus:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r")
  2568.          (match_operand:DI 2 "reg_or_short_operand" "r,I")))]
  2569.   "TARGET_POWER"
  2570.   "@
  2571.    {a|addc} %L0,%L1,%L2\;{ae|adde} %0,%1,%2
  2572.    {ai|addic} %L0,%L1,%2\;{a%G2e|add%G2e} %0,%1"
  2573.   [(set_attr "length" "8")])
  2574.  
  2575. (define_insn ""
  2576.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
  2577.     (plus:DI (match_operand:DI 1 "gpc_reg_operand" "%r")
  2578.          (match_operand:DI 2 "gpc_reg_operand" "r")))]
  2579.   "! TARGET_POWER"
  2580.   "addc %L0,%L1,%L2\;adde %0,%1,%2"
  2581.   [(set_attr "length" "8")])
  2582.  
  2583. (define_expand "subdi3"
  2584.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
  2585.     (minus:DI (match_operand:DI 1 "reg_or_short_operand" "r,I")
  2586.           (match_operand:DI 2 "gpc_reg_operand" "r,r")))]
  2587.   ""
  2588.   "
  2589. {
  2590.   if (! TARGET_POWER
  2591.       && short_cint_operand (operands[1], DImode))
  2592.     FAIL;
  2593. }")
  2594.  
  2595. (define_insn ""
  2596.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
  2597.     (minus:DI (match_operand:DI 1 "reg_or_short_operand" "r,I")
  2598.           (match_operand:DI 2 "gpc_reg_operand" "r,r")))]
  2599.   "TARGET_POWER"
  2600.   "@
  2601.    {sf|subfc} %L0,%L2,%L1\;{sfe|subfe} %0,%2,%1
  2602.    {sfi|subfic} %L0,%L2,%1\;{sf%G1e|subf%G1e} %0,%2"
  2603.   [(set_attr "length" "8")])
  2604.  
  2605. (define_insn ""
  2606.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
  2607.     (minus:DI (match_operand:DI 1 "gpc_reg_operand" "r")
  2608.           (match_operand:DI 2 "gpc_reg_operand" "r")))]
  2609.   "! TARGET_POWER"
  2610.   "subfc %L0,%L2,%L1\;subfe %0,%2,%1"
  2611.   [(set_attr "length" "8")])
  2612.  
  2613. (define_expand "negdi2"
  2614.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
  2615.     (neg:DI (match_operand:DI 1 "gpc_reg_operand" "r")))]
  2616.   ""
  2617.   "")
  2618.  
  2619. (define_insn ""
  2620.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
  2621.     (neg:DI (match_operand:DI 1 "gpc_reg_operand" "r")))]
  2622.   ""
  2623.   "{sfi|subfic} %L0,%L1,0\;{sfze|subfze} %0,%1"
  2624.   [(set_attr "length" "8")])
  2625.  
  2626. (define_insn "mulsidi3"
  2627.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
  2628.     (mult:DI (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r"))
  2629.          (sign_extend:DI (match_operand:SI 2 "gpc_reg_operand" "r"))))
  2630.    (clobber (match_scratch:SI 3 "=q"))]
  2631.   "TARGET_POWER"
  2632.   "mul %0,%1,%2\;mfmq %L0"
  2633.   [(set_attr "length" "8")])
  2634.  
  2635. ;; If operands 0 and 2 are in the same register, we have a problem.  But
  2636. ;; operands 0 and 1 (the usual case) can be in the same register.  That's
  2637. ;; why we have the strange constraints below.
  2638. (define_insn "ashldi3"
  2639.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r,&r")
  2640.     (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,0,r")
  2641.            (match_operand:SI 2 "reg_or_cint_operand" "M,i,r,r")))
  2642.    (clobber (match_scratch:SI 3 "=X,q,q,q"))]
  2643.   "TARGET_POWER"
  2644.   "@
  2645.    {sli|slwi} %0,%L1,%h2\;{cal %L0,0(0)|li %L0,0}
  2646.    sl%I2q %L0,%L1,%h2\;sll%I2q %0,%1,%h2
  2647.    sl%I2q %L0,%L1,%h2\;sll%I2q %0,%1,%h2
  2648.    sl%I2q %L0,%L1,%h2\;sll%I2q %0,%1,%h2"
  2649.   [(set_attr "length" "8")])
  2650.  
  2651. (define_insn "lshrdi3"
  2652.   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,r,r,&r")
  2653.     (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,0,r")
  2654.              (match_operand:SI 2 "reg_or_cint_operand" "M,i,r,r")))
  2655.    (clobber (match_scratch:SI 3 "=X,q,q,q"))]
  2656.   "TARGET_POWER"
  2657.   "@
  2658.    {cal %0,0(0)|li %0,0}\;{s%A2i|s%A2wi} %L0,%1,%h2
  2659.    sr%I2q %0,%1,%h2\;srl%I2q %L0,%L1,%h2
  2660.    sr%I2q %0,%1,%h2\;srl%I2q %L0,%L1,%h2
  2661.    sr%I2q %0,%1,%h2\;srl%I2q %L0,%L1,%h2"
  2662.   [(set_attr "length" "8")])
  2663.  
  2664. ;; Shift by a variable amount is too complex to be worth open-coding.  We
  2665. ;; just handle shifts by constants.
  2666.  
  2667. (define_expand "ashrdi3"
  2668.   [(parallel [(set (match_operand:DI 0 "gpc_reg_operand" "=")
  2669.            (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "")
  2670.                 (match_operand:SI 2 "general_operand" "")))
  2671.           (clobber (match_scratch:SI 3 ""))])]
  2672.   "TARGET_POWER"
  2673.   "
  2674. { if (GET_CODE (operands[2]) != CONST_INT)
  2675.     FAIL;
  2676. }")
  2677.  
  2678. (define_insn ""
  2679.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
  2680.     (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
  2681.              (match_operand:SI 2 "const_int_operand" "M,i")))
  2682.    (clobber (match_scratch:SI 3 "=X,q"))]
  2683.   "TARGET_POWER"
  2684.   "@
  2685.    {srai|srawi} %0,%1,31\;{srai|srawi} %L0,%1,%h2
  2686.    sraiq %0,%1,%h2\;srliq %L0,%L1,%h2"
  2687.   [(set_attr "length" "8")])
  2688.  
  2689. ;; Now define ways of moving data around.
  2690. ;;
  2691. ;; For SI, we special-case integers that can't be loaded in one insn.  We
  2692. ;; do the load 16-bits at a time.  We could do this by loading from memory,
  2693. ;; and this is even supposed to be faster, but it is simpler not to get
  2694. ;; integers in the TOC.
  2695. (define_expand "movsi"
  2696.   [(set (match_operand:SI 0 "general_operand" "")
  2697.     (match_operand:SI 1 "any_operand" ""))]
  2698.   ""
  2699.   "
  2700. {
  2701.   if (GET_CODE (operands[0]) != REG)
  2702.     operands[1] = force_reg (SImode, operands[1]);
  2703.  
  2704.   if (CONSTANT_P (operands[1]) && GET_CODE (operands[1]) != CONST_INT
  2705.       && ! LEGITIMATE_CONSTANT_POOL_ADDRESS_P (operands[1]))
  2706.     {
  2707.       operands[1] = force_const_mem (SImode, operands[1]);
  2708.       if (! memory_address_p (SImode, XEXP (operands[1], 0))
  2709.       && ! reload_in_progress)
  2710.     operands[1] = change_address (operands[1], SImode,
  2711.                       XEXP (operands[1], 0));
  2712.     }
  2713.  
  2714.   if (GET_CODE (operands[1]) == CONST_INT
  2715.       && (unsigned) (INTVAL (operands[1]) + 0x8000) >= 0x10000
  2716.       && (INTVAL (operands[1]) & 0xffff) != 0)
  2717.     {
  2718.       emit_move_insn (operands[0],
  2719.               gen_rtx (CONST_INT, VOIDmode,
  2720.                    INTVAL (operands[1]) & 0xffff0000));
  2721.       emit_insn (gen_iorsi3 (operands[0], operands[0],
  2722.                  gen_rtx (CONST_INT, VOIDmode,
  2723.                       INTVAL (operands[1]) & 0xffff)));
  2724.       DONE;
  2725.     }
  2726. }")
  2727.  
  2728. (define_insn ""
  2729.   [(set (match_operand:SI 0 "nonimmediate_operand" "=r,r,m,r,r,r,*c*q,*l,*h")
  2730.     (match_operand:SI 1 "input_operand" "r,m,r,I,J,*h,r,r,0"))]
  2731.   "TARGET_POWER && (gpc_reg_operand (operands[0], SImode)
  2732.    || gpc_reg_operand (operands[1], SImode))"
  2733.   "@
  2734.    {ai|addic} %0,%1,0
  2735.    {l%U1%X1|lwz%U1%X1} %0,%1
  2736.    {st%U0%X0|stw%U0%X0} %1,%0
  2737.    {cal %0,%1(0)|li %0,%1}
  2738.    {cau %0,0,%u1|lis %0,%u1}
  2739.    mf%1 %0
  2740.    mt%0 %1
  2741.    mt%0 %1
  2742.    cror 0,0,0"
  2743.   [(set_attr "type" "*,load,*,*,*,*,*,mtlr,*")])
  2744.  
  2745. (define_insn ""
  2746.   [(set (match_operand:SI 0 "nonimmediate_operand" "=r,r,m,r,r,r,*h")
  2747.     (match_operand:SI 1 "input_operand" "r,m,r,I,J,*h,r"))]
  2748.   "! TARGET_POWER && (gpc_reg_operand (operands[0], SImode)
  2749.    || gpc_reg_operand (operands[1], SImode))"
  2750.   "@
  2751.    mr %0,%1
  2752.    lwz%U1%X1 %0,%1
  2753.    stw%U0%X0 %1,%0
  2754.    li %0,%1
  2755.    lis %0,%u1
  2756.    mf%1 %0
  2757.    mt%0 %1"
  2758.   [(set_attr "type" "*,load,*,*,*,*,*")])
  2759.  
  2760. ;; Split a load of a large constant into the appropriate two-insn
  2761. ;; sequence.
  2762.  
  2763. (define_split
  2764.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  2765.     (match_operand:SI 1 "const_int_operand" ""))]
  2766.   "(unsigned) (INTVAL (operands[1]) + 0x8000) >= 0x10000
  2767.    && (INTVAL (operands[1]) & 0xffff) != 0"
  2768.   [(set (match_dup 0)
  2769.     (match_dup 2))
  2770.    (set (match_dup 0)
  2771.     (ior:SI (match_dup 0)
  2772.         (match_dup 3)))]
  2773.   "
  2774. {
  2775.   operands[2] = gen_rtx (CONST_INT, VOIDmode,
  2776.              INTVAL (operands[1]) & 0xffff0000);
  2777.   operands[3] = gen_rtx (CONST_INT, VOIDmode, INTVAL (operands[1]) & 0xffff);
  2778. }")
  2779.  
  2780. (define_insn ""
  2781.   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
  2782.     (compare:CC (match_operand:SI 1 "gpc_reg_operand" "r")
  2783.             (const_int 0)))
  2784.    (set (match_operand:SI 0 "gpc_reg_operand" "=r") (match_dup 1))]
  2785.   ""
  2786.   "{ai.|addic.} %0,%1,0"
  2787.   [(set_attr "type" "compare")])
  2788.  
  2789. (define_expand "movhi"
  2790.   [(set (match_operand:HI 0 "general_operand" "")
  2791.     (match_operand:HI 1 "any_operand" ""))]
  2792.   ""
  2793.   "
  2794. {
  2795.   if (GET_CODE (operands[0]) != REG)
  2796.     operands[1] = force_reg (HImode, operands[1]);
  2797.  
  2798.   if (CONSTANT_P (operands[1]) && GET_CODE (operands[1]) != CONST_INT)
  2799.     {
  2800.       operands[1] = force_const_mem (HImode, operands[1]);
  2801.       if (! memory_address_p (HImode, XEXP (operands[1], 0))
  2802.       && ! reload_in_progress)
  2803.     operands[1] = change_address (operands[1], HImode,
  2804.                       XEXP (operands[1], 0));
  2805.     }
  2806. }")
  2807.  
  2808. (define_insn ""
  2809.   [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,m,r,r,*h,*h")
  2810.     (match_operand:HI 1 "input_operand" "r,m,r,i,*h,r,0"))]
  2811.   "TARGET_POWER && (gpc_reg_operand (operands[0], HImode)
  2812.    || gpc_reg_operand (operands[1], HImode))"
  2813.   "@
  2814.    {oril|ori} %0,%1,0
  2815.    lhz%U1%X1 %0,%1
  2816.    sth%U0%X0 %1,%0
  2817.    {cal %0,%w1(0)|li %0,%w1}
  2818.    mf%1 %0
  2819.    mt%0 %1
  2820.    cror 0,0,0"
  2821.   [(set_attr "type" "*,load,*,*,*,*,*")])
  2822.  
  2823. (define_insn ""
  2824.   [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,m,r,r,*h")
  2825.     (match_operand:HI 1 "input_operand" "r,m,r,i,*h,r"))]
  2826.   "! TARGET_POWER && (gpc_reg_operand (operands[0], HImode)
  2827.    || gpc_reg_operand (operands[1], HImode))"
  2828.   "@
  2829.    ori %0,%1,0
  2830.    lhz%U1%X1 %0,%1
  2831.    sth%U0%X0 %1,%0
  2832.    li %0,%w1
  2833.    mf%1 %0
  2834.    mt%0 %1"
  2835.   [(set_attr "type" "*,load,*,*,*,*")])
  2836.  
  2837. (define_expand "movqi"
  2838.   [(set (match_operand:QI 0 "general_operand" "")
  2839.     (match_operand:QI 1 "any_operand" ""))]
  2840.   ""
  2841.   "
  2842. {
  2843.   if (GET_CODE (operands[0]) != REG)
  2844.     operands[1] = force_reg (QImode, operands[1]);
  2845.  
  2846.   if (CONSTANT_P (operands[1]) && GET_CODE (operands[1]) != CONST_INT)
  2847.     {
  2848.       operands[1] = force_const_mem (QImode, operands[1]);
  2849.       if (! memory_address_p (QImode, XEXP (operands[1], 0))
  2850.       && ! reload_in_progress)
  2851.     operands[1] = change_address (operands[1], QImode,
  2852.                       XEXP (operands[1], 0));
  2853.     }
  2854. }")
  2855.  
  2856. (define_insn ""
  2857.   [(set (match_operand:QI 0 "nonimmediate_operand" "=r,r,m,r,r,*h,*h")
  2858.     (match_operand:QI 1 "input_operand" "r,m,r,i,*h,r,0"))]
  2859.   "TARGET_POWER && (gpc_reg_operand (operands[0], QImode)
  2860.    || gpc_reg_operand (operands[1], QImode))"
  2861.   "@
  2862.    {oril|ori} %0,%1,0
  2863.    lbz%U1%X1 %0,%1
  2864.    stb%U0%X0 %1,%0
  2865.    {cal %0,%1(0)|li %0,%1}
  2866.    mf%1 %0
  2867.    mt%0 %1
  2868.    cror 0,0,0"
  2869.   [(set_attr "type" "*,load,*,*,*,*,*")])
  2870.  
  2871. (define_insn ""
  2872.   [(set (match_operand:QI 0 "nonimmediate_operand" "=r,r,m,r,r,*h")
  2873.     (match_operand:QI 1 "input_operand" "r,m,r,i,*h,r"))]
  2874.   "! TARGET_POWER && (gpc_reg_operand (operands[0], QImode)
  2875.    || gpc_reg_operand (operands[1], QImode))"
  2876.   "@
  2877.    mr %0,%1
  2878.    lbz%U1%X1 %0,%1
  2879.    stb%U0%X0 %1,%0
  2880.    li %0,%1
  2881.    mf%1 %0
  2882.    mt%0 %1"
  2883.   [(set_attr "type" "*,load,*,*,*,*")])
  2884.  
  2885. ;; Here is how to move condition codes around.  When we store CC data in
  2886. ;; an integer register or memory, we store just the high-order 4 bits.
  2887. ;; This lets us not shift in the most common case of CR0.
  2888. (define_expand "movcc"
  2889.   [(set (match_operand:CC 0 "nonimmediate_operand" "")
  2890.     (match_operand:CC 1 "nonimmediate_operand" ""))]
  2891.   ""
  2892.   "")
  2893.  
  2894. (define_insn ""
  2895.   [(set (match_operand:CC 0 "nonimmediate_operand" "=y,x,y,r,r,r,r,m")
  2896.     (match_operand:CC 1 "nonimmediate_operand" "y,r,r,x,y,r,m,r"))]
  2897.   "register_operand (operands[0], CCmode)
  2898.    || register_operand (operands[1], CCmode)"
  2899.   "@
  2900.    mcrf %0,%1
  2901.    mtcrf 128,%1
  2902.    {rlinm|rlwinm} %1,%1,%F0,0xffffffff\;mtcrf %R0,%1\;{rlinm|rlwinm} %1,%1,%f0,0xffffffff
  2903.    mfcr %0
  2904.    mfcr %0\;{rlinm|rlwinm} %0,%0,%f1,0xf0000000
  2905.    {ai %0,%1,0|mr %0,%1}
  2906.    {l%U1%X1|lwz%U1%X1} %0,%1
  2907.    {st%U0%U1|stw%U0%U1} %1,%0"
  2908.   [(set_attr "type" "*,*,*,compare,*,*,load,*")
  2909.    (set_attr "length" "*,*,12,*,8,*,*,*")])
  2910.  
  2911. ;; For floating-point, we normally deal with the floating-point registers.
  2912. ;; The sole exception is that parameter passing can produce floating-point
  2913. ;; values in fixed-point registers.  Unless the value is a simple constant
  2914. ;; or already in memory, we deal with this by allocating memory and copying
  2915. ;; the value explicitly via that memory location.
  2916. (define_expand "movsf"
  2917.   [(set (match_operand:SF 0 "nonimmediate_operand" "")
  2918.     (match_operand:SF 1 "any_operand" ""))]
  2919.   ""
  2920.   "
  2921. {
  2922.   /* If we are called from reload, we might be getting a SUBREG of a hard
  2923.      reg.  So expand it.  */
  2924.   if (GET_CODE (operands[0]) == SUBREG
  2925.       && GET_CODE (SUBREG_REG (operands[0])) == REG
  2926.       && REGNO (SUBREG_REG (operands[0])) < FIRST_PSEUDO_REGISTER)
  2927.     operands[0] = alter_subreg (operands[0]);
  2928.   if (GET_CODE (operands[1]) == SUBREG
  2929.       && GET_CODE (SUBREG_REG (operands[1])) == REG
  2930.       && REGNO (SUBREG_REG (operands[1])) < FIRST_PSEUDO_REGISTER)
  2931.     operands[1] = alter_subreg (operands[1]);
  2932.  
  2933.   if (GET_CODE (operands[1]) == REG && REGNO (operands[1]) < 32)
  2934.     {
  2935.       rtx stack_slot;
  2936.  
  2937.       /* If this is a store to memory or another integer register do the
  2938.      move directly.  Otherwise store to a temporary stack slot and
  2939.      load from there into a floating point register.  */
  2940.  
  2941.       if (GET_CODE (operands[0]) == MEM
  2942.       || (GET_CODE (operands[0]) == REG
  2943.           && (REGNO (operands[0]) < 32
  2944.           || (reload_in_progress
  2945.               && REGNO (operands[0]) >= FIRST_PSEUDO_REGISTER))))
  2946.     {
  2947.       emit_move_insn (operand_subword (operands[0], 0, 0, SFmode),
  2948.               operand_subword (operands[1], 0, 0, SFmode));
  2949.       DONE;
  2950.     }
  2951.  
  2952.       stack_slot = gen_rtx (MEM, SFmode, plus_constant (stack_pointer_rtx, 4));
  2953.       emit_move_insn (stack_slot, operands[1]);
  2954.       emit_move_insn (operands[0], stack_slot);
  2955.       DONE;
  2956.     }
  2957.  
  2958.   if (GET_CODE (operands[0]) == MEM)
  2959.     operands[1] = force_reg (SFmode, operands[1]);
  2960.  
  2961.   if (GET_CODE (operands[0]) == REG && REGNO (operands[0]) < 32)
  2962.     {
  2963.       rtx stack_slot;
  2964.  
  2965.       if (GET_CODE (operands[1]) == MEM
  2966. #if HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT && ! defined(REAL_IS_NOT_DOUBLE)
  2967.       || GET_CODE (operands[1]) == CONST_DOUBLE
  2968. #endif
  2969.       || (GET_CODE (operands[1]) == REG && REGNO (operands[1]) < 32)
  2970.       || (reload_in_progress && GET_CODE (operands[1]) == REG
  2971.           && REGNO (operands[1]) >= FIRST_PSEUDO_REGISTER))
  2972.     {
  2973.       emit_move_insn (operand_subword (operands[0], 0, 0, SFmode),
  2974.               operand_subword (operands[1], 0, 0, SFmode));
  2975.       DONE;
  2976.     }
  2977.  
  2978.       if (reload_in_progress)
  2979.     stack_slot = gen_rtx (MEM, SFmode,
  2980.                   plus_constant (stack_pointer_rtx, 4));
  2981.       else
  2982.     stack_slot = assign_stack_temp (SFmode, 4, 0);
  2983.       emit_move_insn (stack_slot, operands[1]);
  2984.       emit_move_insn (operands[0], stack_slot);
  2985.       DONE;
  2986.     }
  2987.  
  2988.   if (CONSTANT_P (operands[1]))
  2989.     {
  2990.       operands[1] = force_const_mem (SFmode, operands[1]);
  2991.       if (! memory_address_p (SFmode, XEXP (operands[1], 0))
  2992.       && ! reload_in_progress)
  2993.     operands[1] = change_address (operands[1], SFmode,
  2994.                       XEXP (operands[1], 0));
  2995.     }
  2996. }")
  2997.  
  2998. (define_split
  2999.   [(set (match_operand:SF 0 "gpc_reg_operand" "")
  3000.     (match_operand:SF 1 "easy_fp_constant" ""))]
  3001.   "reload_completed && REGNO (operands[0]) <= 31"
  3002.   [(set (match_dup 2) (match_dup 3))]
  3003.   "
  3004. { operands[2] = operand_subword (operands[0], 0, 0, SFmode);
  3005.   operands[3] = operand_subword (operands[1], 0, 0, SFmode); }")
  3006.   
  3007. (define_insn ""
  3008.   [(set (match_operand:SF 0 "fp_reg_or_mem_operand" "=f,f,m")
  3009.     (match_operand:SF 1 "input_operand" "f,m,f"))]
  3010.   "gpc_reg_operand (operands[0], SFmode)
  3011.    || gpc_reg_operand (operands[1], SFmode)"
  3012.   "@
  3013.    fmr %0,%1
  3014.    lfs%U1%X1 %0,%1
  3015.    frsp %1,%1\;stfs%U0%X0 %1,%0"
  3016.   [(set_attr "type" "fp,fpload,*")
  3017.    (set_attr "length" "*,*,8")])
  3018.  
  3019. (define_expand "movdf"
  3020.   [(set (match_operand:DF 0 "nonimmediate_operand" "")
  3021.     (match_operand:DF 1 "any_operand" ""))]
  3022.   ""
  3023.   "
  3024. {
  3025.   if (GET_CODE (operands[0]) == MEM && GET_CODE (operands[1]) == MEM)
  3026.     {
  3027.       emit_move_insn (operand_subword (operands[0], 1, 1, DFmode),
  3028.               operand_subword_force (operands[1], 1, DFmode));
  3029.       emit_move_insn (operand_subword (operands[0], 0, 1, DFmode),
  3030.               operand_subword_force (operands[1], 0, DFmode));
  3031.       DONE;
  3032.     }
  3033.  
  3034.   if (GET_CODE (operands[0]) != REG)
  3035.     operands[1] = force_reg (DFmode, operands[1]);
  3036.  
  3037.   if (CONSTANT_P (operands[1]) && ! easy_fp_constant (operands[1], DFmode))
  3038.     {
  3039.       operands[1] = force_const_mem (DFmode, operands[1]);
  3040.       if (! memory_address_p (DFmode, XEXP (operands[1], 0))
  3041.       && ! reload_in_progress)
  3042.     operands[1] = change_address (operands[1], DFmode,
  3043.                       XEXP (operands[1], 0));
  3044.     }
  3045. }")
  3046.  
  3047. (define_split
  3048.   [(set (match_operand:DF 0 "gpc_reg_operand" "")
  3049.     (match_operand:DF 1 "easy_fp_constant" ""))]
  3050.   "reload_completed && REGNO (operands[0]) <= 31"
  3051.   [(set (match_dup 2) (match_dup 3))
  3052.    (set (match_dup 4) (match_dup 5))]
  3053.   "
  3054. { operands[2] = operand_subword (operands[0], 0, 0, DFmode);
  3055.   operands[3] = operand_subword (operands[1], 0, 0, DFmode);
  3056.   operands[4] = operand_subword (operands[0], 1, 0, DFmode);
  3057.   operands[5] = operand_subword (operands[1], 1, 0, DFmode); }")
  3058.  
  3059. ;; Don't have reload use general registers to load a constant.  First,
  3060. ;; it might not work if the output operand has is the equivalent of
  3061. ;; a non-offsettable memref, but also it is less efficient than loading
  3062. ;; the constant into an FP register, since it will probably be used there.
  3063. ;; The "??" is a kludge until we can figure out a more reasonable way
  3064. ;; of handling these non-offsettable values.
  3065. (define_insn ""
  3066.   [(set (match_operand:DF 0 "nonimmediate_operand" "=!r,??r,o,!r,f,f,m")
  3067.     (match_operand:DF 1 "input_operand" "r,o,r,G,f,m,f"))]
  3068.   "register_operand (operands[0], DFmode)
  3069.    || register_operand (operands[1], DFmode)"
  3070.   "*
  3071. {
  3072.   switch (which_alternative)
  3073.     {
  3074.     case 0:
  3075.       /* We normally copy the low-numbered register first.  However, if
  3076.      the first register operand 0 is the same as the second register of
  3077.      operand 1, we must copy in the opposite order.  */
  3078.       if (REGNO (operands[0]) == REGNO (operands[1]) + 1)
  3079.     return \"{oril %L0,%L1,0|mr %L0,%L1}\;{oril %0,%1,0|mr %0,%1}\";
  3080.       else
  3081.     return \"{oril %0,%1,0|mr %0,%1}\;{oril %L0,%L1,0|mr %L0,%L1}\";
  3082.     case 1:
  3083.       /* If the low-address word is used in the address, we must load it
  3084.      last.  Otherwise, load it first.  Note that we cannot have
  3085.      auto-increment in that case since the address register is known to be
  3086.      dead.  */
  3087.       if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
  3088.                  operands [1], 0))
  3089.     return \"{l|lwz} %L0,%L1\;{l|lwz} %0,%1\";
  3090.       else
  3091.     return \"{l%U1|lwz%U1} %0,%1\;{l|lwz} %L0,%L1\";
  3092.     case 2:
  3093.       return \"{st%U0|stw%U0} %1,%0\;{st|stw} %L1,%L0\";
  3094.     case 3:
  3095.       return \"#\";
  3096.     case 4:
  3097.       return \"fmr %0,%1\";
  3098.     case 5:
  3099.       return \"lfd%U1%X1 %0,%1\";
  3100.     case 6:
  3101.       return \"stfd%U0%X0 %1,%0\";
  3102.     }
  3103. }"
  3104.   [(set_attr "type" "*,load,*,*,fp,fpload,*")
  3105.    (set_attr "length" "8,8,8,8,*,*,*")])
  3106.  
  3107. ;; Next come the multi-word integer load and store and the load and store
  3108. ;; multiple insns.
  3109. (define_expand "movdi"
  3110.   [(set (match_operand:DI 0 "general_operand" "")
  3111.     (match_operand:DI 1 "general_operand" ""))]
  3112.   ""
  3113.   "
  3114. {
  3115.   if (GET_CODE (operands[1]) == CONST_DOUBLE
  3116.       || GET_CODE (operands[1]) == CONST_INT)
  3117.     {
  3118.       emit_move_insn (operand_subword (operands[0], 0, 0, DImode),
  3119.               operand_subword (operands[1], 0, 0, DImode));
  3120.       emit_move_insn (operand_subword (operands[0], 1, 0, DImode),
  3121.               operand_subword (operands[1], 1, 0, DImode));
  3122.       DONE;
  3123.     }
  3124.  
  3125.   if (GET_CODE (operands[0]) == MEM)
  3126.     operands[1] = force_reg (DImode, operands[1]);
  3127. }")
  3128.  
  3129. (define_insn ""
  3130.   [(set (match_operand:DI 0 "nonimmediate_operand" "=r,r,m")
  3131.     (match_operand:DI 1 "input_operand" "r,m,r"))]
  3132.   "gpc_reg_operand (operands[0], DImode)
  3133.    || gpc_reg_operand (operands[1], DImode)"
  3134.   "*
  3135. {
  3136.   switch (which_alternative)
  3137.     {
  3138.     case 0:
  3139.       /* We normally copy the low-numbered register first.  However, if
  3140.      the first register operand 0 is the same as the second register of
  3141.      operand 1, we must copy in the opposite order.  */
  3142.       if (REGNO (operands[0]) == REGNO (operands[1]) + 1)
  3143.     return \"{oril %L0,%L1,0|mr %L0,%L1}\;{oril %0,%1,0|mr %0,%1}\";
  3144.       else
  3145.     return \"{oril %0,%1,0|mr %0,%1}\;{oril %L0,%L1,0|mr %L0,%L1}\";
  3146.     case 1:
  3147.       /* If the low-address word is used in the address, we must load it
  3148.      last.  Otherwise, load it first.  Note that we cannot have
  3149.      auto-increment in that case since the address register is known to be
  3150.      dead.  */
  3151.       if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
  3152.                  operands [1], 0))
  3153.     return \"{l|lwz} %L0,%L1\;{l|lwz} %0,%1\";
  3154.       else
  3155.     return \"{l%U1|lwz%U1} %0,%1\;{l|lwz} %L0,%L1\";
  3156.     case 2:
  3157.       return \"{st%U0|stw%U0} %1,%0\;{st|stw} %L1,%L0\";
  3158.     }
  3159. }"
  3160.   [(set_attr "type" "*,load,*")
  3161.    (set_attr "length" "8")])
  3162.  
  3163. ;; TImode is similar, except that we usually want to compute the address into
  3164. ;; a register and use lsi/stsi (the exception is during reload).  MQ is also
  3165. ;; clobbered in stsi for POWER, so we need a SCRATCH for it.
  3166. (define_expand "movti"
  3167.   [(parallel [(set (match_operand:TI 0 "general_operand" "")
  3168.            (match_operand:TI 1 "general_operand" ""))
  3169.           (clobber (scratch:SI))])]
  3170.   "TARGET_POWER"
  3171.   "
  3172. {
  3173.   if (GET_CODE (operands[0]) == MEM)
  3174.     operands[1] = force_reg (TImode, operands[1]);
  3175.  
  3176.   if (GET_CODE (operands[0]) == MEM
  3177.       && GET_CODE (XEXP (operands[0], 0)) != REG
  3178.       && ! reload_in_progress)
  3179.     operands[0] = change_address (operands[0], TImode,
  3180.                   copy_addr_to_reg (XEXP (operands[0], 0)));
  3181.  
  3182.   if (GET_CODE (operands[1]) == MEM
  3183.       && GET_CODE (XEXP (operands[1], 0)) != REG
  3184.       && ! reload_in_progress)
  3185.     operands[1] = change_address (operands[1], TImode,
  3186.                   copy_addr_to_reg (XEXP (operands[1], 0)));
  3187. }")
  3188.  
  3189. ;; We say that MQ is clobbered in the last alternative because the first
  3190. ;; alternative would never get used otherwise since it would need a reload
  3191. ;; while the 2nd alternative would not.  We put memory cases first so they
  3192. ;; are preferred.  Otherwise, we'd try to reload the output instead of
  3193. ;; giving the SCRATCH mq.
  3194. (define_insn ""
  3195.   [(set (match_operand:TI 0 "reg_or_mem_operand" "=Q,m,r,r,r")
  3196.     (match_operand:TI 1 "reg_or_mem_operand" "r,r,r,Q,m"))
  3197.    (clobber (match_scratch:SI 2 "=q,q#X,X,X,X"))]
  3198.   "TARGET_POWER && (gpc_reg_operand (operands[0], TImode)
  3199.    || gpc_reg_operand (operands[1], TImode))"
  3200.   "*
  3201. {
  3202.   switch (which_alternative)
  3203.     {
  3204.     case 0:
  3205.       return \"{stsi|stswi} %1,%P0,16\";
  3206.  
  3207.     case 1:
  3208.       return \"{st%U0|stw%U0} %1,%0\;{st|stw} %L1,%L0\;{st|stw} %Y1,%Y0\;{st|stw} %Z1,%Z0\";
  3209.  
  3210.     case 2:
  3211.       /* Normally copy registers with lowest numbered register copied first.
  3212.      But copy in the other order if the first register of the output
  3213.      is the second, third, or fourth register in the input.  */
  3214.       if (REGNO (operands[0]) >= REGNO (operands[1]) + 1
  3215.       && REGNO (operands[0]) <= REGNO (operands[1]) + 3)
  3216.     return \"{oril %Z0,%Z1,0|mr %Z0,%Z1}\;{oril %Y0,%Y1,0|mr %Y0,%Y1}\;{oril %L0,%L1,0|mr %L0,%L1}\;{oril %0,%1,0|mr %0,%1}\";
  3217.       else
  3218.     return \"{oril %0,%1,0|mr %0,%1}\;{oril %L0,%L1,0|mr %L0,%L1}\;{oril %Y0,%Y1,0|mr %Y0,%Y1}\;{oril %Z0,%Z1,0|mr %Z0,%Z1}\";
  3219.     case 3:
  3220.       /* If the address is not used in the output, we can use lsi.  Otherwise,
  3221.      fall through to generating four loads.  */
  3222.       if (! reg_overlap_mentioned_p (operands[0], operands[1]))
  3223.     return \"{lsi|lswi} %0,%P1,16\";
  3224.       /* ... fall through ... */
  3225.     case 4:
  3226.       /* If the address register is the same as the register for the lowest-
  3227.      addressed word, load it last.  Similarly for the next two words.
  3228.      Otherwise load lowest address to highest.  */
  3229.       if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
  3230.                  operands[1], 0))
  3231.     return \"{l|lwz} %L0,%L1\;{l|lwz} %Y0,%Y1\;{l|lwz} %Z0,%Z1\;{l|lwz} %0,%1\";
  3232.       else if (refers_to_regno_p (REGNO (operands[0]) + 1,
  3233.                   REGNO (operands[0]) + 2, operands[1], 0))
  3234.     return \"{l|lwz} %0,%1\;{l|lwz} %Y0,%Y1\;{l|lwz} %Z0,%Z1\;{l|lwz} %L0,%L1\";
  3235.       else if (refers_to_regno_p (REGNO (operands[0]) + 2,
  3236.                   REGNO (operands[0]) + 3, operands[1], 0))
  3237.     return \"{l|lwz} %0,%1\;{l|lwz} %L0,%L1\;{l|lwz} %Z0,%Z1\;{l|lwz} %Y0,%Y1\";
  3238.       else
  3239.     return \"{l%U1|lwz%U1} %0,%1\;{l|lwz} %L0,%L1\;{l|lwz} %Y0,%Y1\;{l|lwz} %Z0,%Z1\";
  3240.     }
  3241. }"
  3242.   [(set_attr "type" "*,load,load,*,*")
  3243.    (set_attr "length" "*,16,16,*,16")])
  3244.  
  3245. (define_expand "load_multiple"
  3246.   [(match_par_dup 3 [(set (match_operand:SI 0 "" "")
  3247.               (match_operand:SI 1 "" ""))
  3248.              (use (match_operand:SI 2 "" ""))])]
  3249.   "TARGET_POWER"
  3250.   "
  3251. {
  3252.   int regno;
  3253.   int count;
  3254.   rtx from;
  3255.   int i;
  3256.  
  3257.   /* Support only loading a constant number of fixed-point registers from
  3258.      memory and only bother with this if more than two; the machine
  3259.      doesn't support more than eight.  */
  3260.   if (GET_CODE (operands[2]) != CONST_INT
  3261.       || INTVAL (operands[2]) <= 2
  3262.       || INTVAL (operands[2]) > 8
  3263.       || GET_CODE (operands[1]) != MEM
  3264.       || GET_CODE (operands[0]) != REG
  3265.       || REGNO (operands[0]) >= 32)
  3266.     FAIL;
  3267.  
  3268.   count = INTVAL (operands[2]);
  3269.   regno = REGNO (operands[0]);
  3270.  
  3271.   operands[3] = gen_rtx (PARALLEL, VOIDmode, rtvec_alloc (count));
  3272.   from = force_reg (SImode, XEXP (operands[1], 0));
  3273.  
  3274.   for (i = 0; i < count; i++)
  3275.     XVECEXP (operands[3], 0, i)
  3276.       = gen_rtx (SET, VOIDmode, gen_rtx (REG, SImode, regno + i),
  3277.          gen_rtx (MEM, SImode, plus_constant (from, i * 4)));
  3278. }")
  3279.  
  3280. (define_insn ""
  3281.   [(match_parallel 0 "load_multiple_operation"
  3282.            [(set (match_operand:SI 1 "gpc_reg_operand" "=r")
  3283.              (match_operand:SI 2 "indirect_operand" "Q"))])]
  3284.   "TARGET_POWER"
  3285.   "*
  3286. {
  3287.   /* We have to handle the case where the pseudo used to contain the address
  3288.      is assigned to one of the output registers.  In that case, do the
  3289.      lsi, but then load the correct value.  This is a bit of a mess, but is
  3290.      the best we can do.
  3291.      We set the length attribute to the maximum possible size (8 bytes).  */
  3292.   static char result[100];
  3293.   char newload[40];
  3294.   int i;
  3295.  
  3296.   strcpy (result, \"{lsi|lswi} %1,%P2,%N0\");
  3297.   for (i = 0; i < XVECLEN (operands[0], 0); i++)
  3298.     if (refers_to_regno_p (REGNO (operands[1]) + i,
  3299.                REGNO (operands[1]) + i + 1, operands[2], 0))
  3300.       {
  3301.     sprintf (newload, \"\;{l|lwz} %d,%d(%d)\",
  3302.          REGNO (operands[1]) + i,
  3303.          i * 4, REGNO (XEXP (operands[2], 0)));
  3304.     strcat (result, newload);
  3305.       }
  3306.  
  3307.   return result;
  3308. }"
  3309.   [(set_attr "type" "load")
  3310.    (set_attr "length" "8")])
  3311.  
  3312.  
  3313. (define_expand "store_multiple"
  3314.   [(match_par_dup 3 [(set (match_operand:SI 0 "" "")
  3315.               (match_operand:SI 1 "" ""))
  3316.              (clobber (scratch:SI))
  3317.              (use (match_operand:SI 2 "" ""))])]
  3318.   "TARGET_POWER"
  3319.   "
  3320. {
  3321.   int regno;
  3322.   int count;
  3323.   rtx to;
  3324.   int i;
  3325.  
  3326.   /* Support only storing a constant number of fixed-point registers to
  3327.      memory and only bother with this if more than two; the machine
  3328.      doesn't support more than eight.  */
  3329.   if (GET_CODE (operands[2]) != CONST_INT
  3330.       || INTVAL (operands[2]) <= 2
  3331.       || INTVAL (operands[2]) > 8
  3332.       || GET_CODE (operands[0]) != MEM
  3333.       || GET_CODE (operands[1]) != REG
  3334.       || REGNO (operands[1]) >= 32)
  3335.     FAIL;
  3336.  
  3337.   count = INTVAL (operands[2]);
  3338.   regno = REGNO (operands[1]);
  3339.  
  3340.   operands[3] = gen_rtx (PARALLEL, VOIDmode, rtvec_alloc (count + 1));
  3341.   to = force_reg (SImode, XEXP (operands[0], 0));
  3342.  
  3343.   XVECEXP (operands[3], 0, 0)
  3344.     = gen_rtx (SET, VOIDmode, gen_rtx (MEM, SImode, to), operands[1]);
  3345.   XVECEXP (operands[3], 0, 1) = gen_rtx (CLOBBER, VOIDmode,
  3346.                           gen_rtx (SCRATCH, SImode));
  3347.  
  3348.   for (i = 1; i < count; i++)
  3349.     XVECEXP (operands[3], 0, i + 1)
  3350.       = gen_rtx (SET, VOIDmode,
  3351.          gen_rtx (MEM, SImode, plus_constant (to, i * 4)),
  3352.          gen_rtx (REG, SImode, regno + i));
  3353. }")
  3354.  
  3355. (define_insn ""
  3356.   [(match_parallel 0 "store_multiple_operation"
  3357.            [(set (match_operand:SI 1 "indirect_operand" "=Q")
  3358.              (match_operand:SI 2 "gpc_reg_operand" "r"))
  3359.             (clobber (match_scratch:SI 3 "=q"))])]
  3360.   "TARGET_POWER"
  3361.   "{stsi|stswi} %2,%P1,%O0")
  3362.  
  3363. ;; Define insns that do load or store with update.  Some of these we can 
  3364. ;; get by using pre-decrement or pre-increment, but the hardware can also
  3365. ;; do cases where the increment is not the size of the object.
  3366. ;;
  3367. ;; In all these cases, we use operands 0 and 1 for the register being
  3368. ;; incremented because those are the operands that local-alloc will
  3369. ;; tie and these are the pair most likely to be tieable (and the ones
  3370. ;; that will benefit the most).
  3371.  
  3372. (define_insn ""
  3373.   [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
  3374.     (mem:SI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  3375.              (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
  3376.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  3377.     (plus:SI (match_dup 1) (match_dup 2)))]
  3378.   ""
  3379.   "@
  3380.    {lux|lwzux} %3,%0,%2
  3381.    {lu|lwzu} %3,%2(%0)"
  3382.   [(set_attr "type" "load")])
  3383.  
  3384. (define_insn ""
  3385.   [(set (mem:SI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  3386.              (match_operand:SI 2 "reg_or_short_operand" "r,I")))
  3387.     (match_operand:SI 3 "gpc_reg_operand" "r,r"))
  3388.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  3389.     (plus:SI (match_dup 1) (match_dup 2)))]
  3390.   ""
  3391.   "@
  3392.    {stux|stwux} %3,%0,%2
  3393.    {stu|stwu} %3,%2(%0)")
  3394.  
  3395. (define_insn ""
  3396.   [(set (match_operand:HI 3 "gpc_reg_operand" "=r,r")
  3397.     (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  3398.              (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
  3399.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  3400.     (plus:SI (match_dup 1) (match_dup 2)))]
  3401.   ""
  3402.   "@
  3403.    lhzux %3,%0,%2
  3404.    lhzu %3,%2(%0)"
  3405.   [(set_attr "type" "load")])
  3406.  
  3407. (define_insn ""
  3408.   [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
  3409.     (zero_extend:SI
  3410.      (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  3411.               (match_operand:SI 2 "reg_or_short_operand" "r,I")))))
  3412.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  3413.     (plus:SI (match_dup 1) (match_dup 2)))]
  3414.   ""
  3415.   "@
  3416.    lhzux %3,%0,%2
  3417.    lhzu %3,%2(%0)"
  3418.   [(set_attr "type" "load")])
  3419.  
  3420. (define_insn ""
  3421.   [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
  3422.     (sign_extend:SI
  3423.      (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  3424.               (match_operand:SI 2 "reg_or_short_operand" "r,I")))))
  3425.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  3426.     (plus:SI (match_dup 1) (match_dup 2)))]
  3427.   ""
  3428.   "@
  3429.    lhaux %3,%0,%2
  3430.    lhau %3,%2(%0)"
  3431.   [(set_attr "type" "load")])
  3432.  
  3433. (define_insn ""
  3434.   [(set (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  3435.              (match_operand:SI 2 "reg_or_short_operand" "r,I")))
  3436.     (match_operand:HI 3 "gpc_reg_operand" "r,r"))
  3437.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  3438.     (plus:SI (match_dup 1) (match_dup 2)))]
  3439.   ""
  3440.   "@
  3441.    sthux %3,%0,%2
  3442.    sthu %3,%2(%0)")
  3443.  
  3444. (define_insn ""
  3445.   [(set (match_operand:QI 3 "gpc_reg_operand" "=r,r")
  3446.     (mem:QI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  3447.              (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
  3448.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  3449.     (plus:SI (match_dup 1) (match_dup 2)))]
  3450.   ""
  3451.   "@
  3452.    lbzux %3,%0,%2
  3453.    lbzu %3,%2(%0)"
  3454.   [(set_attr "type" "load")])
  3455.  
  3456. (define_insn ""
  3457.   [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
  3458.     (zero_extend:SI
  3459.      (mem:QI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  3460.               (match_operand:SI 2 "reg_or_short_operand" "r,I")))))
  3461.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  3462.     (plus:SI (match_dup 1) (match_dup 2)))]
  3463.   ""
  3464.   "@
  3465.    lbzux %3,%0,%2
  3466.    lbzu %3,%2(%0)"
  3467.   [(set_attr "type" "load")])
  3468.  
  3469. (define_insn ""
  3470.   [(set (mem:QI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  3471.              (match_operand:SI 2 "reg_or_short_operand" "r,I")))
  3472.     (match_operand:QI 3 "gpc_reg_operand" "r,r"))
  3473.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  3474.     (plus:SI (match_dup 1) (match_dup 2)))]
  3475.   ""
  3476.   "@
  3477.    stbux %3,%0,%2
  3478.    stbu %3,%2(%0)")
  3479.  
  3480. (define_insn ""
  3481.   [(set (match_operand:SF 3 "gpc_reg_operand" "=f,f")
  3482.     (mem:SI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  3483.              (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
  3484.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  3485.     (plus:SI (match_dup 1) (match_dup 2)))]
  3486.   ""
  3487.   "@
  3488.    lfsux %3,%0,%2
  3489.    lfsu %3,%2(%0)"
  3490.   [(set_attr "type" "fpload")])
  3491.  
  3492. (define_insn ""
  3493.   [(set (mem:SF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  3494.              (match_operand:SI 2 "reg_or_short_operand" "r,I")))
  3495.     (match_operand:SF 3 "gpc_reg_operand" "f,f"))
  3496.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  3497.     (plus:SI (match_dup 1) (match_dup 2)))]
  3498.   ""
  3499.   "@
  3500.    frsp %3,%3\;stfsux %3,%0,%2
  3501.    frsp %3,%3\;stfsu %3,%2(%0)")
  3502.  
  3503. (define_insn ""
  3504.   [(set (match_operand:DF 3 "gpc_reg_operand" "=f,f")
  3505.     (mem:DF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  3506.              (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
  3507.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  3508.     (plus:SI (match_dup 1) (match_dup 2)))]
  3509.   ""
  3510.   "@
  3511.    lfdux %3,%0,%2
  3512.    lfdu %3,%2(%0)"
  3513.   [(set_attr "type" "fpload")])
  3514.  
  3515. (define_insn ""
  3516.   [(set (mem:DF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  3517.              (match_operand:SI 2 "reg_or_short_operand" "r,I")))
  3518.     (match_operand:DF 3 "gpc_reg_operand" "f,f"))
  3519.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  3520.     (plus:SI (match_dup 1) (match_dup 2)))]
  3521.   ""
  3522.   "@
  3523.    stfdux %3,%0,%2
  3524.    stfdu %3,%2(%0)")
  3525.  
  3526. ;; Next come insns related to the calling sequence.
  3527. ;;
  3528. ;; First, an insn to allocate new stack space for dynamic use (e.g., alloca).
  3529. ;; We move the back-chain and decrement the stack pointer.  
  3530.  
  3531. (define_expand "allocate_stack"
  3532.   [(set (reg:SI 1)
  3533.     (minus:SI (reg:SI 1) (match_operand:SI 0 "reg_or_short_operand" "")))]
  3534.   ""
  3535.   "
  3536. { rtx chain = gen_reg_rtx (SImode);
  3537.   rtx stack_bot = gen_rtx (MEM, Pmode, stack_pointer_rtx);
  3538.  
  3539.   emit_move_insn (chain, stack_bot);
  3540.   emit_insn (gen_subsi3 (stack_pointer_rtx, stack_pointer_rtx, operands[0]));
  3541.   emit_move_insn (stack_bot, chain);
  3542.   DONE;
  3543. }")
  3544.  
  3545. ;; These patterns say how to save and restore the stack pointer.  We need not
  3546. ;; save the stack pointer at function level since we are careful to
  3547. ;; preserve the backchain.  At block level, we have to restore the backchain
  3548. ;; when we restore the stack pointer.
  3549. ;;
  3550. ;; For nonlocal gotos, we must save both the stack pointer and its
  3551. ;; backchain and restore both.  Note that in the nonlocal case, the
  3552. ;; save area is a memory location.
  3553.  
  3554. (define_expand "save_stack_function"
  3555.   [(use (const_int 0))]
  3556.   ""
  3557.   "")
  3558.  
  3559. (define_expand "restore_stack_function"
  3560.   [(use (const_int 0))]
  3561.   ""
  3562.   "")
  3563.  
  3564. (define_expand "restore_stack_block"
  3565.   [(set (match_dup 2) (mem:SI (match_operand:SI 0 "register_operand" "")))
  3566.    (set (match_dup 0) (match_operand:SI 1 "register_operand" ""))
  3567.    (set (mem:SI (match_dup 0)) (match_dup 2))]
  3568.   ""
  3569.   "
  3570. { operands[2] = gen_reg_rtx (SImode); }")
  3571.  
  3572. (define_expand "save_stack_nonlocal"
  3573.   [(match_operand:DI 0 "memory_operand" "")
  3574.    (match_operand:SI 1 "register_operand" "")]
  3575.   ""
  3576.   "
  3577. {
  3578.   rtx temp = gen_reg_rtx (SImode);
  3579.  
  3580.   /* Copy the backchain to the first word, sp to the second.  */
  3581.   emit_move_insn (temp, gen_rtx (MEM, SImode, operands[1]));
  3582.   emit_move_insn (operand_subword (operands[0], 0, 0, DImode), temp);
  3583.   emit_move_insn (operand_subword (operands[0], 1, 0, DImode), operands[1]);
  3584.   DONE;
  3585. }")
  3586.           
  3587. (define_expand "restore_stack_nonlocal"
  3588.   [(match_operand:SI 0 "register_operand" "")
  3589.    (match_operand:DI 1 "memory_operand" "")]
  3590.   ""
  3591.   "
  3592. {
  3593.   rtx temp = gen_reg_rtx (SImode);
  3594.  
  3595.   /* Restore the backchain from the first word, sp from the second.  */
  3596.   emit_move_insn (temp, operand_subword (operands[1], 0, 0, DImode));
  3597.   emit_move_insn (operands[0], operand_subword (operands[1], 1, 0, DImode));
  3598.   emit_move_insn (gen_rtx (MEM, SImode, operands[0]), temp);
  3599.   DONE;
  3600. }")
  3601.  
  3602. ;; A function pointer is a pointer to a data area whose first word contains
  3603. ;; the actual address of the function, whose second word contains a pointer
  3604. ;; to its TOC, and whose third word contains a value to place in the static
  3605. ;; chain register (r11).  Note that if we load the static chain, our 
  3606. ;; "trampoline" need not have any executable code.
  3607. ;;
  3608. ;; operands[0] is an SImode pseudo in which we place the address of the
  3609. ;;            function.
  3610. ;; operands[1] is the address of data area of the function to call
  3611.  
  3612. (define_expand "call_via_ptr"
  3613.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  3614.     (mem:SI (match_operand:SI 1 "gpc_reg_operand" "")))
  3615.    (set (mem:SI (plus:SI (reg:SI 1) (const_int 20)))
  3616.     (reg:SI 2))
  3617.    (set (reg:SI 2)
  3618.     (mem:SI (plus:SI (match_dup 1)
  3619.              (const_int 4))))
  3620.    (set (reg:SI 11)
  3621.     (mem:SI (plus:SI (match_dup 1)
  3622.              (const_int 8))))
  3623.    (use (reg:SI 2))
  3624.    (use (reg:SI 11))]
  3625.   ""
  3626.   "")
  3627.  
  3628. (define_expand "call"
  3629.   [(parallel [(call (mem:SI (match_operand:SI 0 "address_operand" ""))
  3630.             (match_operand 1 "" ""))
  3631.           (clobber (scratch:SI))])]
  3632.   ""
  3633.   "
  3634. {
  3635.   if (GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != CONST_INT)
  3636.     abort ();
  3637.  
  3638.   operands[0] = XEXP (operands[0], 0);
  3639.   if (GET_CODE (operands[0]) != SYMBOL_REF)
  3640.     {
  3641.       rtx temp = gen_reg_rtx (SImode);
  3642.  
  3643.       emit_insn (gen_call_via_ptr (temp, force_reg (SImode, operands[0])));
  3644.       operands[0] = temp;
  3645.     }
  3646. }")
  3647.  
  3648. (define_expand "call_value"
  3649.   [(parallel [(set (match_operand 0 "" "")
  3650.            (call (mem:SI (match_operand:SI 1 "address_operand" ""))
  3651.              (match_operand 2 "" "")))
  3652.           (clobber (scratch:SI))])]
  3653.   ""
  3654.   "
  3655. {
  3656.   if (GET_CODE (operands[1]) != MEM || GET_CODE (operands[2]) != CONST_INT)
  3657.     abort ();
  3658.  
  3659.   operands[1] = XEXP (operands[1], 0);
  3660.   if (GET_CODE (operands[1]) != SYMBOL_REF)
  3661.     {
  3662.       rtx temp = gen_reg_rtx (SImode);
  3663.  
  3664.       emit_insn (gen_call_via_ptr (temp, force_reg (SImode, operands[1])));
  3665.       operands[1] = temp;
  3666.     }
  3667. }")
  3668.  
  3669. ;; Call to function in current module.  No TOC pointer reload needed.
  3670.  
  3671. (define_insn ""
  3672.   [(call (mem:SI (match_operand:SI 0 "current_file_function_operand" "s"))
  3673.      (match_operand 1 "" "g"))
  3674.    (clobber (match_scratch:SI 2 "=l"))]
  3675.   ""
  3676.   "bl %z0")
  3677.  
  3678. ;; Call to function which may be in another module.  Restore the TOC
  3679. ;; pointer (r2) after the call.
  3680.  
  3681. (define_insn ""
  3682.   [(call (mem:SI (match_operand:SI 0 "call_operand" "l,s"))
  3683.      (match_operand 1 "" "fg,fg"))
  3684.    (clobber (match_scratch:SI 2 "=l,l"))]
  3685.   ""
  3686.   "@
  3687.    {brl|blrl}\;{l|lwz} 2,20(1)
  3688.    bl %z0\;%."
  3689.   [(set_attr "length" "8")])
  3690.  
  3691. (define_insn ""
  3692.   [(set (match_operand 0 "" "=fg")
  3693.     (call (mem:SI (match_operand:SI 1 "current_file_function_operand" "s"))
  3694.           (match_operand 2 "" "g")))
  3695.    (clobber (match_scratch:SI 3 "=l"))]
  3696.   ""
  3697.   "bl %z1")
  3698.  
  3699. (define_insn ""
  3700.   [(set (match_operand 0 "" "=fg,fg")
  3701.     (call (mem:SI (match_operand:SI 1 "call_operand" "l,s"))
  3702.           (match_operand 2 "" "fg,fg")))
  3703.    (clobber (match_scratch:SI 3 "=l,l"))]
  3704.   ""
  3705.   "@
  3706.    {brl|blrl}\;{l|lwz} 2,20(1)
  3707.    bl %z1\;%."
  3708.   [(set_attr "length" "8")])
  3709.  
  3710. ;; Call subroutine returning any type.
  3711.  
  3712. (define_expand "untyped_call"
  3713.   [(parallel [(call (match_operand 0 "" "")
  3714.             (const_int 0))
  3715.           (match_operand 1 "" "")
  3716.           (match_operand 2 "" "")])]
  3717.   ""
  3718.   "
  3719. {
  3720.   int i;
  3721.  
  3722.   emit_call_insn (gen_call (operands[0], const0_rtx, NULL, const0_rtx));
  3723.  
  3724.   for (i = 0; i < XVECLEN (operands[2], 0); i++)
  3725.     {
  3726.       rtx set = XVECEXP (operands[2], 0, i);
  3727.       emit_move_insn (SET_DEST (set), SET_SRC (set));
  3728.     }
  3729.  
  3730.   /* The optimizer does not know that the call sets the function value
  3731.      registers we stored in the result block.  We avoid problems by
  3732.      claiming that all hard registers are used and clobbered at this
  3733.      point.  */
  3734.   emit_insn (gen_blockage ());
  3735.  
  3736.   DONE;
  3737. }")
  3738.  
  3739. ;; UNSPEC_VOLATILE is considered to use and clobber all hard registers and
  3740. ;; all of memory.  This blocks insns from being moved across this point.
  3741.  
  3742. (define_insn "blockage"
  3743.   [(unspec_volatile [(const_int 0)] 0)]
  3744.   ""
  3745.   "")
  3746.  
  3747. ;; Compare insns are next.  Note that the RS/6000 has two types of compares,
  3748. ;; signed & unsigned, and one type of branch.  
  3749. ;;
  3750. ;; Start with the DEFINE_EXPANDs to generate the rtl for compares, scc
  3751. ;; insns, and branches.  We store the operands of compares until we see
  3752. ;; how it is used.
  3753. (define_expand "cmpsi"
  3754.   [(set (cc0)
  3755.         (compare (match_operand:SI 0 "gpc_reg_operand" "")
  3756.            (match_operand:SI 1 "reg_or_short_operand" "")))]
  3757.   ""
  3758.   "
  3759. {
  3760.   /* Take care of the possibility that operands[1] might be negative but
  3761.      this might be a logical operation.  That insn doesn't exist.  */
  3762.   if (GET_CODE (operands[1]) == CONST_INT
  3763.       && INTVAL (operands[1]) < 0)
  3764.     operands[1] = force_reg (SImode, operands[1]);
  3765.  
  3766.   rs6000_compare_op0 = operands[0];
  3767.   rs6000_compare_op1 = operands[1];
  3768.   rs6000_compare_fp_p = 0;
  3769.   DONE;
  3770. }")
  3771.  
  3772. (define_expand "cmpsf"
  3773.   [(set (cc0) (compare (match_operand:SF 0 "gpc_reg_operand" "")
  3774.                (match_operand:SF 1 "gpc_reg_operand" "")))]
  3775.   ""
  3776.   "
  3777. {
  3778.   rs6000_compare_op0 = operands[0];
  3779.   rs6000_compare_op1 = operands[1];
  3780.   rs6000_compare_fp_p = 1;
  3781.   DONE;
  3782. }")
  3783.  
  3784. (define_expand "cmpdf"
  3785.   [(set (cc0) (compare (match_operand:DF 0 "gpc_reg_operand" "")
  3786.                (match_operand:DF 1 "gpc_reg_operand" "")))]
  3787.   ""
  3788.   "
  3789. {
  3790.   rs6000_compare_op0 = operands[0];
  3791.   rs6000_compare_op1 = operands[1];
  3792.   rs6000_compare_fp_p = 1;
  3793.   DONE;
  3794. }")
  3795.  
  3796. (define_expand "beq"
  3797.   [(set (match_dup 2) (match_dup 1))
  3798.    (set (pc)
  3799.     (if_then_else (eq (match_dup 2)
  3800.               (const_int 0))
  3801.               (label_ref (match_operand 0 "" ""))
  3802.               (pc)))]
  3803.   ""
  3804.   "
  3805. { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
  3806.   operands[1] = gen_rtx (COMPARE, mode,
  3807.              rs6000_compare_op0, rs6000_compare_op1);
  3808.   operands[2] = gen_reg_rtx (mode);
  3809. }")
  3810.  
  3811. (define_expand "bne"
  3812.   [(set (match_dup 2) (match_dup 1))
  3813.    (set (pc)
  3814.     (if_then_else (ne (match_dup 2)
  3815.               (const_int 0))
  3816.               (label_ref (match_operand 0 "" ""))
  3817.               (pc)))]
  3818.   ""
  3819.   "
  3820. { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
  3821.   operands[1] = gen_rtx (COMPARE, mode,
  3822.              rs6000_compare_op0, rs6000_compare_op1);
  3823.   operands[2] = gen_reg_rtx (mode);
  3824. }")
  3825.  
  3826. (define_expand "blt"
  3827.   [(set (match_dup 2) (match_dup 1))
  3828.    (set (pc)
  3829.     (if_then_else (lt (match_dup 2)
  3830.               (const_int 0))
  3831.               (label_ref (match_operand 0 "" ""))
  3832.               (pc)))]
  3833.   ""
  3834.   "
  3835. { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
  3836.   operands[1] = gen_rtx (COMPARE, mode,
  3837.              rs6000_compare_op0, rs6000_compare_op1);
  3838.   operands[2] = gen_reg_rtx (mode);
  3839. }")
  3840.  
  3841. (define_expand "bgt"
  3842.   [(set (match_dup 2) (match_dup 1))
  3843.    (set (pc)
  3844.     (if_then_else (gt (match_dup 2)
  3845.               (const_int 0))
  3846.               (label_ref (match_operand 0 "" ""))
  3847.               (pc)))]
  3848.   ""
  3849.   "
  3850. { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
  3851.   operands[1] = gen_rtx (COMPARE, mode,
  3852.              rs6000_compare_op0, rs6000_compare_op1);
  3853.   operands[2] = gen_reg_rtx (mode);
  3854. }")
  3855.  
  3856. (define_expand "ble"
  3857.   [(set (match_dup 2) (match_dup 1))
  3858.    (set (pc)
  3859.     (if_then_else (le (match_dup 2)
  3860.               (const_int 0))
  3861.               (label_ref (match_operand 0 "" ""))
  3862.               (pc)))]
  3863.   ""
  3864.   "
  3865. { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
  3866.   operands[1] = gen_rtx (COMPARE, mode,
  3867.              rs6000_compare_op0, rs6000_compare_op1);
  3868.   operands[2] = gen_reg_rtx (mode);
  3869. }")
  3870.  
  3871. (define_expand "bge"
  3872.   [(set (match_dup 2) (match_dup 1))
  3873.    (set (pc)
  3874.     (if_then_else (ge (match_dup 2)
  3875.               (const_int 0))
  3876.               (label_ref (match_operand 0 "" ""))
  3877.               (pc)))]
  3878.   ""
  3879.   "
  3880. { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
  3881.   operands[1] = gen_rtx (COMPARE, mode,
  3882.              rs6000_compare_op0, rs6000_compare_op1);
  3883.   operands[2] = gen_reg_rtx (mode);
  3884. }")
  3885.  
  3886. (define_expand "bgtu"
  3887.   [(set (match_dup 2) (match_dup 1))
  3888.    (set (pc)
  3889.     (if_then_else (gtu (match_dup 2)
  3890.                (const_int 0))
  3891.               (label_ref (match_operand 0 "" ""))
  3892.               (pc)))]
  3893.   ""
  3894.   "
  3895. { operands[1] = gen_rtx (COMPARE, CCUNSmode,
  3896.              rs6000_compare_op0, rs6000_compare_op1);
  3897.   operands[2] = gen_reg_rtx (CCUNSmode);
  3898. }")
  3899.  
  3900. (define_expand "bltu"
  3901.   [(set (match_dup 2) (match_dup 1))
  3902.    (set (pc)
  3903.     (if_then_else (ltu (match_dup 2)
  3904.                (const_int 0))
  3905.               (label_ref (match_operand 0 "" ""))
  3906.               (pc)))]
  3907.   ""
  3908.   "
  3909. { operands[1] = gen_rtx (COMPARE, CCUNSmode,
  3910.              rs6000_compare_op0, rs6000_compare_op1);
  3911.   operands[2] = gen_reg_rtx (CCUNSmode);
  3912. }")
  3913.  
  3914. (define_expand "bgeu"
  3915.   [(set (match_dup 2) (match_dup 1))
  3916.    (set (pc)
  3917.     (if_then_else (geu (match_dup 2)
  3918.                (const_int 0))
  3919.               (label_ref (match_operand 0 "" ""))
  3920.               (pc)))]
  3921.   ""
  3922.   "
  3923. { operands[1] = gen_rtx (COMPARE, CCUNSmode,
  3924.              rs6000_compare_op0, rs6000_compare_op1);
  3925.   operands[2] = gen_reg_rtx (CCUNSmode);
  3926. }")
  3927.  
  3928. (define_expand "bleu"
  3929.   [(set (match_dup 2) (match_dup 1))
  3930.    (set (pc)
  3931.     (if_then_else (leu (match_dup 2)
  3932.                (const_int 0))
  3933.               (label_ref (match_operand 0 "" ""))
  3934.               (pc)))]
  3935.   ""
  3936.   "
  3937. { operands[1] = gen_rtx (COMPARE, CCUNSmode,
  3938.              rs6000_compare_op0, rs6000_compare_op1);
  3939.   operands[2] = gen_reg_rtx (CCUNSmode);
  3940. }")
  3941.  
  3942. ;; For SNE, we would prefer that the xor/abs sequence be used for integers.
  3943. ;; For SEQ, likewise, except that comparisons with zero should be done
  3944. ;; with an scc insns.  However, due to the order that combine see the
  3945. ;; resulting insns, we must, in fact, allow SEQ for integers.  Fail in
  3946. ;; the cases we don't want to handle.
  3947. (define_expand "seq"
  3948.   [(set (match_dup 2) (match_dup 1))
  3949.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  3950.     (eq:SI (match_dup 2) (const_int 0)))]
  3951.   ""
  3952.   "
  3953. { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
  3954.   operands[1] = gen_rtx (COMPARE, mode,
  3955.              rs6000_compare_op0, rs6000_compare_op1);
  3956.   operands[2] = gen_reg_rtx (mode);
  3957. }")
  3958.  
  3959. (define_expand "sne"
  3960.   [(set (match_dup 2) (match_dup 1))
  3961.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  3962.     (ne:SI (match_dup 2) (const_int 0)))]
  3963.   ""
  3964.   "
  3965. { if (! rs6000_compare_fp_p)
  3966.     FAIL;
  3967.  
  3968.   operands[1] = gen_rtx (COMPARE, CCFPmode,
  3969.              rs6000_compare_op0, rs6000_compare_op1);
  3970.   operands[2] = gen_reg_rtx (CCFPmode);
  3971. }")
  3972.  
  3973. ;; A > 0 is best done using the portable sequence, so fail in that case.
  3974. (define_expand "sgt"
  3975.   [(set (match_dup 2) (match_dup 1))
  3976.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  3977.     (gt:SI (match_dup 2) (const_int 0)))]
  3978.   ""
  3979.   "
  3980. { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
  3981.  
  3982.   if (! rs6000_compare_fp_p && rs6000_compare_op1 == const0_rtx)
  3983.     FAIL;
  3984.  
  3985.   operands[1] = gen_rtx (COMPARE, mode,
  3986.              rs6000_compare_op0, rs6000_compare_op1);
  3987.   operands[2] = gen_reg_rtx (mode);
  3988. }")
  3989.  
  3990. ;; A < 0 is best done in the portable way for A an integer.
  3991. (define_expand "slt"
  3992.   [(set (match_dup 2) (match_dup 1))
  3993.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  3994.     (lt:SI (match_dup 2) (const_int 0)))]
  3995.   ""
  3996.   "
  3997. { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
  3998.  
  3999.   if (! rs6000_compare_fp_p && rs6000_compare_op1 == const0_rtx)
  4000.     FAIL;
  4001.  
  4002.   operands[1] = gen_rtx (COMPARE, mode,
  4003.              rs6000_compare_op0, rs6000_compare_op1);
  4004.   operands[2] = gen_reg_rtx (mode);
  4005. }")
  4006.  
  4007. (define_expand "sge"
  4008.   [(set (match_dup 2) (match_dup 1))
  4009.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  4010.     (ge:SI (match_dup 2) (const_int 0)))]
  4011.   ""
  4012.   "
  4013. { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
  4014.   operands[1] = gen_rtx (COMPARE, mode,
  4015.              rs6000_compare_op0, rs6000_compare_op1);
  4016.   operands[2] = gen_reg_rtx (mode);
  4017. }")
  4018.  
  4019. ;; A <= 0 is best done the portable way for A an integer.
  4020. (define_expand "sle"
  4021.   [(set (match_dup 2) (match_dup 1))
  4022.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  4023.     (le:SI (match_dup 2) (const_int 0)))]
  4024.   ""
  4025.   "
  4026. { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
  4027.  
  4028.   if (! rs6000_compare_fp_p && rs6000_compare_op1 == const0_rtx)
  4029.     FAIL;
  4030.  
  4031.   operands[1] = gen_rtx (COMPARE, mode,
  4032.              rs6000_compare_op0, rs6000_compare_op1);
  4033.   operands[2] = gen_reg_rtx (mode);
  4034. }")
  4035.  
  4036. (define_expand "sgtu"
  4037.   [(set (match_dup 2) (match_dup 1))
  4038.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  4039.     (gtu:SI (match_dup 2) (const_int 0)))]
  4040.   ""
  4041.   "
  4042. { operands[1] = gen_rtx (COMPARE, CCUNSmode,
  4043.              rs6000_compare_op0, rs6000_compare_op1);
  4044.   operands[2] = gen_reg_rtx (CCUNSmode);
  4045. }")
  4046.  
  4047. (define_expand "sltu"
  4048.   [(set (match_dup 2) (match_dup 1))
  4049.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  4050.     (ltu:SI (match_dup 2) (const_int 0)))]
  4051.   ""
  4052.   "
  4053. { operands[1] = gen_rtx (COMPARE, CCUNSmode,
  4054.              rs6000_compare_op0, rs6000_compare_op1);
  4055.   operands[2] = gen_reg_rtx (CCUNSmode);
  4056. }")
  4057.  
  4058. (define_expand "sgeu"
  4059.   [(set (match_dup 2) (match_dup 1))
  4060.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  4061.     (geu:SI (match_dup 2) (const_int 0)))]
  4062.   ""
  4063.   "
  4064. { operands[1] = gen_rtx (COMPARE, CCUNSmode,
  4065.              rs6000_compare_op0, rs6000_compare_op1);
  4066.   operands[2] = gen_reg_rtx (CCUNSmode);
  4067. }")
  4068.  
  4069. (define_expand "sleu"
  4070.   [(set (match_dup 2) (match_dup 1))
  4071.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  4072.     (leu:SI (match_dup 2) (const_int 0)))]
  4073.   ""
  4074.   "
  4075. { operands[1] = gen_rtx (COMPARE, CCUNSmode,
  4076.              rs6000_compare_op0, rs6000_compare_op1);
  4077.   operands[2] = gen_reg_rtx (CCUNSmode);
  4078. }")
  4079.  
  4080. ;; Here are the actual compare insns.
  4081. (define_insn ""
  4082.   [(set (match_operand:CC 0 "cc_reg_operand" "=y")
  4083.     (compare:CC (match_operand:SI 1 "gpc_reg_operand" "r")
  4084.             (match_operand:SI 2 "reg_or_short_operand" "rI")))]
  4085.   ""
  4086.   "{cmp%I2|cmpw%I2} %0,%1,%2"
  4087.   [(set_attr "type" "compare")])
  4088.  
  4089. ;; If we are comparing a register for equality with a large constant,
  4090. ;; we can do this with an XOR followed by a compare.  But we need a scratch
  4091. ;; register for the result of the XOR.
  4092.  
  4093. (define_split
  4094.   [(set (match_operand:CC 0 "cc_reg_operand" "")
  4095.     (compare:CC (match_operand:SI 1 "gpc_reg_operand" "")
  4096.             (match_operand:SI 2 "non_short_cint_operand" "")))
  4097.    (clobber (match_operand:SI 3 "gpc_reg_operand" ""))]
  4098.   "find_single_use (operands[0], insn, 0)
  4099.    && (GET_CODE (*find_single_use (operands[0], insn, 0)) == EQ
  4100.        || GET_CODE (*find_single_use (operands[0], insn, 0)) == NE)"
  4101.   [(set (match_dup 3) (xor:SI (match_dup 1) (match_dup 4)))
  4102.    (set (match_dup 0) (compare:CC (match_dup 3) (match_dup 5)))]
  4103.   "
  4104. {
  4105.   /* Get the constant we are comparing against, C,  and see what it looks like
  4106.      sign-extended to 16 bits.  Then see what constant could be XOR'ed
  4107.      with C to get the sign-extended value.  */
  4108.  
  4109.   int c = INTVAL (operands[2]);
  4110.   int sextc = (c << 16) >> 16;
  4111.   int xorv = c ^ sextc;
  4112.  
  4113.   operands[4] = gen_rtx (CONST_INT, VOIDmode, xorv);
  4114.   operands[5] = gen_rtx (CONST_INT, VOIDmode, sextc);
  4115. }")
  4116.  
  4117. (define_insn ""
  4118.   [(set (match_operand:CCUNS 0 "cc_reg_operand" "=y")
  4119.     (compare:CCUNS (match_operand:SI 1 "gpc_reg_operand" "r")
  4120.                (match_operand:SI 2 "reg_or_u_short_operand" "rI")))]
  4121.   ""
  4122.   "{cmpl%I2|cmplw%I2} %0,%1,%W2"
  4123.   [(set_attr "type" "compare")])
  4124.  
  4125. ;; The following two insns don't exist as single insns, but if we provide
  4126. ;; them, we can swap an add and compare, which will enable us to overlap more
  4127. ;; of the required delay between a compare and branch.  We generate code for
  4128. ;; them by splitting.
  4129.  
  4130. (define_insn ""
  4131.   [(set (match_operand:CC 3 "cc_reg_operand" "=y")
  4132.     (compare:CC (match_operand:SI 1 "gpc_reg_operand" "r")
  4133.             (match_operand:SI 2 "short_cint_operand" "i")))
  4134.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4135.     (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "i")))]
  4136.   ""
  4137.   "#"
  4138.   [(set_attr "length" "8")])
  4139.    
  4140. (define_insn ""
  4141.   [(set (match_operand:CCUNS 3 "cc_reg_operand" "=y")
  4142.     (compare:CCUNS (match_operand:SI 1 "gpc_reg_operand" "r")
  4143.                (match_operand:SI 2 "u_short_cint_operand" "i")))
  4144.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4145.     (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "i")))]
  4146.   ""
  4147.   "#"
  4148.   [(set_attr "length" "8")])
  4149.    
  4150. (define_split
  4151.   [(set (match_operand:CC 3 "cc_reg_operand" "")
  4152.     (compare:CC (match_operand:SI 1 "gpc_reg_operand" "")
  4153.             (match_operand:SI 2 "short_cint_operand" "")))
  4154.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  4155.     (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "")))]
  4156.   ""
  4157.   [(set (match_dup 3) (compare:CC (match_dup 1) (match_dup 2)))
  4158.    (set (match_dup 0) (plus:SI (match_dup 1) (match_dup 4)))])
  4159.  
  4160. (define_split
  4161.   [(set (match_operand:CCUNS 3 "cc_reg_operand" "")
  4162.     (compare:CCUNS (match_operand:SI 1 "gpc_reg_operand" "")
  4163.                (match_operand:SI 2 "u_short_cint_operand" "")))
  4164.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  4165.     (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "")))]
  4166.   ""
  4167.   [(set (match_dup 3) (compare:CCUNS (match_dup 1) (match_dup 2)))
  4168.    (set (match_dup 0) (plus:SI (match_dup 1) (match_dup 4)))])
  4169.  
  4170. (define_insn ""
  4171.   [(set (match_operand:CCFP 0 "cc_reg_operand" "=y")
  4172.     (compare:CCFP (match_operand:SF 1 "gpc_reg_operand" "f")
  4173.               (match_operand:SF 2 "gpc_reg_operand" "f")))]
  4174.   ""
  4175.   "fcmpu %0,%1,%2"
  4176.   [(set_attr "type" "fpcompare")])
  4177.  
  4178. (define_insn ""
  4179.   [(set (match_operand:CCFP 0 "cc_reg_operand" "=y")
  4180.     (compare:CCFP (match_operand:DF 1 "gpc_reg_operand" "f")
  4181.               (match_operand:DF 2 "gpc_reg_operand" "f")))]
  4182.   ""
  4183.   "fcmpu %0,%1,%2"
  4184.   [(set_attr "type" "fpcompare")])
  4185.  
  4186. ;; Now we have the scc insns.  We can do some combinations because of the
  4187. ;; way the machine works.
  4188. ;;
  4189. ;; Note that this is probably faster if we can put an insn between the
  4190. ;; mfcr and rlinm, but this is tricky.  Let's leave it for now.  In most
  4191. ;; cases the insns below which don't use an intermediate CR field will
  4192. ;; be used instead.
  4193. (define_insn ""
  4194.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4195.     (match_operator:SI 1 "scc_comparison_operator"
  4196.                [(match_operand 2 "cc_reg_operand" "y")
  4197.                 (const_int 0)]))]
  4198.   ""
  4199.   "%D1mfcr %0\;{rlinm|rlwinm} %0,%0,%J1,1"
  4200.   [(set_attr "length" "12")])
  4201.  
  4202. (define_insn ""
  4203.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  4204.     (compare:CC (match_operator:SI 1 "scc_comparison_operator"
  4205.                        [(match_operand 2 "cc_reg_operand" "y")
  4206.                     (const_int 0)])
  4207.             (const_int 0)))
  4208.    (set (match_operand:SI 3 "gpc_reg_operand" "=r")
  4209.     (match_op_dup 1 [(match_dup 2) (const_int 0)]))]
  4210.   ""
  4211.   "%D1mfcr %3\;{rlinm.|rlwinm.} %3,%3,%J1,1"
  4212.   [(set_attr "type" "delayed_compare")
  4213.    (set_attr "length" "12")])
  4214.  
  4215. (define_insn ""
  4216.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4217.     (ashift:SI (match_operator:SI 1 "scc_comparison_operator"
  4218.                       [(match_operand 2 "cc_reg_operand" "y")
  4219.                        (const_int 0)])
  4220.            (match_operand:SI 3 "const_int_operand" "n")))]
  4221.   ""
  4222.   "*
  4223. {
  4224.   int is_bit = ccr_bit (operands[1], 1);
  4225.   int put_bit = 31 - (INTVAL (operands[3]) & 31);
  4226.   int count;
  4227.  
  4228.   if (is_bit >= put_bit)
  4229.     count = is_bit - put_bit;
  4230.   else
  4231.     count = 32 - (put_bit - is_bit);
  4232.  
  4233.   operands[4] = gen_rtx (CONST_INT, VOIDmode, count);
  4234.   operands[5] = gen_rtx (CONST_INT, VOIDmode, put_bit);
  4235.  
  4236.   return \"%D1mfcr %0\;{rlinm|rlwinm} %0,%0,%4,%5,%5\";
  4237. }"
  4238.  [(set_attr "length" "12")])
  4239.  
  4240. (define_insn ""
  4241.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  4242.     (compare:CC
  4243.      (ashift:SI (match_operator:SI 1 "scc_comparison_operator"
  4244.                        [(match_operand 2 "cc_reg_operand" "y")
  4245.                     (const_int 0)])
  4246.             (match_operand:SI 3 "const_int_operand" "n"))
  4247.      (const_int 0)))
  4248.    (set (match_operand:SI 4 "gpc_reg_operand" "=r")
  4249.     (ashift:SI (match_op_dup 1 [(match_dup 2) (const_int 0)])
  4250.            (match_dup 3)))]
  4251.   ""
  4252.   "*
  4253. {
  4254.   int is_bit = ccr_bit (operands[1], 1);
  4255.   int put_bit = 31 - (INTVAL (operands[3]) & 31);
  4256.   int count;
  4257.  
  4258.   if (is_bit >= put_bit)
  4259.     count = is_bit - put_bit;
  4260.   else
  4261.     count = 32 - (put_bit - is_bit);
  4262.  
  4263.   operands[5] = gen_rtx (CONST_INT, VOIDmode, count);
  4264.   operands[6] = gen_rtx (CONST_INT, VOIDmode, put_bit);
  4265.  
  4266.   return \"%D1mfcr %4\;{rlinm.|rlwinm.} %4,%4,%5,%6,%6\";
  4267. }"
  4268.   [(set_attr "type" "delayed_compare")
  4269.    (set_attr "length" "12")])
  4270.  
  4271. ;; If we are comparing the result of two comparisons, this can be done
  4272. ;; using creqv or crxor.
  4273.  
  4274. (define_insn ""
  4275.   [(set (match_operand:CCEQ 0 "cc_reg_operand" "=y")
  4276.     (compare:CCEQ (match_operator 1 "scc_comparison_operator"
  4277.                   [(match_operand 2 "cc_reg_operand" "y")
  4278.                    (const_int 0)])
  4279.               (match_operator 3 "scc_comparison_operator"
  4280.                   [(match_operand 4 "cc_reg_operand" "y")
  4281.                    (const_int 0)])))]
  4282.   "REGNO (operands[2]) != REGNO (operands[4])"
  4283.   "*
  4284. {
  4285.   enum rtx_code code1, code2;
  4286.  
  4287.   code1 = GET_CODE (operands[1]);
  4288.   code2 = GET_CODE (operands[3]);
  4289.  
  4290.   if ((code1 == EQ || code1 == LT || code1 == GT
  4291.        || code1 == LTU || code1 == GTU
  4292.        || (code1 != NE && GET_MODE (operands[2]) == CCFPmode))
  4293.       !=
  4294.       (code2 == EQ || code2 == LT || code2 == GT
  4295.        || code2 == LTU || code2 == GTU
  4296.        || (code2 != NE && GET_MODE (operands[4]) == CCFPmode)))
  4297.     return \"%C1%C3crxor %E0,%j1,%j3\";
  4298.   else
  4299.     return \"%C1%C3creqv %E0,%j1,%j3\";
  4300. }"
  4301.   [(set_attr "length" "12")])
  4302.  
  4303. ;; There is a 3 cycle delay between consecutive mfcr instructions
  4304. ;; so it is useful to combine 2 scc instructions to use only one mfcr.
  4305.  
  4306. (define_peephole
  4307.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4308.     (match_operator:SI 1 "scc_comparison_operator"
  4309.                [(match_operand 2 "cc_reg_operand" "y")
  4310.                 (const_int 0)]))
  4311.    (set (match_operand:SI 3 "gpc_reg_operand" "=r")
  4312.     (match_operator:SI 4 "scc_comparison_operator"
  4313.                [(match_operand 5 "cc_reg_operand" "y")
  4314.                 (const_int 0)]))]
  4315.    "REGNO (operands[2]) != REGNO (operands[5])"
  4316.    "%D1%D4mfcr %3\;{rlinm|rlwinm} %0,%3,%J1,1\;{rlinm|rlwinm} %3,%3,%J4,1"
  4317.    [(set_attr "length" "20")])
  4318.  
  4319. ;; There are some scc insns that can be done directly, without a compare.
  4320. ;; These are faster because they don't involve the communications between
  4321. ;; the FXU and branch units.   In fact, we will be replacing all of the
  4322. ;; integer scc insns here or in the portable methods in emit_store_flag.
  4323. ;;
  4324. ;; Also support (neg (scc ..)) since that construct is used to replace
  4325. ;; branches, (plus (scc ..) ..) since that construct is common and
  4326. ;; takes no more insns than scc, and (and (neg (scc ..)) ..) in the
  4327. ;; cases where it is no more expensive than (neg (scc ..)).
  4328.  
  4329. ;; Have reload force a constant into a register for the simple insns that
  4330. ;; otherwise won't accept constants.  We do this because it is faster than
  4331. ;; the cmp/mfcr sequence we would otherwise generate.
  4332.  
  4333. (define_insn ""
  4334.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r")
  4335.     (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
  4336.            (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I")))
  4337.    (clobber (match_scratch:SI 3 "=r,&r,r,r,r"))]
  4338.   ""
  4339.   "@
  4340.    xor %0,%1,%2\;{sfi|subfic} %3,%0,0\;{ae|adde} %0,%3,%0
  4341.    {sfi|subfic} %3,%1,0\;{ae|adde} %0,%3,%1
  4342.    {xoril|xori} %0,%1,%b2\;{sfi|subfic} %3,%0,0\;{ae|adde} %0,%3,%0
  4343.    {xoriu|xoris} %0,%1,%u2\;{sfi|subfic} %3,%0,0\;{ae|adde} %0,%3,%0
  4344.    {sfi|subfic} %0,%1,%2\;{sfi|subfic} %3,%0,0\;{ae|adde} %0,%3,%0"
  4345.   [(set_attr "length" "12,8,12,12,12")])
  4346.  
  4347. (define_insn ""
  4348.   [(set (match_operand:CC 4 "cc_reg_operand" "=x,x,x,x,x")
  4349.     (compare:CC 
  4350.      (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
  4351.         (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I"))
  4352.      (const_int 0)))
  4353.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r")
  4354.     (eq:SI (match_dup 1) (match_dup 2)))
  4355.    (clobber (match_scratch:SI 3 "=r,&r,r,r,r"))]
  4356.   ""
  4357.   "@
  4358.    xor %0,%1,%2\;{sfi|subfic} %3,%0,0\;{ae.|adde.} %0,%3,%0
  4359.    {sfi|subfic} %3,%1,0\;{ae.|adde.} %0,%3,%1
  4360.    {xoril|xori} %0,%1,%b2\;{sfi|subfic} %3,%0,0\;{ae.|adde.} %0,%3,%0
  4361.    {xoriu|xoris} %0,%1,%u2\;{sfi|subfic} %3,%0,0\;{ae.|adde.} %0,%3,%0
  4362.    {sfi|subfic} %0,%1,%2\;{sfi|subfic} %3,%0,0\;{ae.|adde.} %0,%3,%0"
  4363.   [(set_attr "type" "compare")
  4364.    (set_attr "length" "12,8,12,12,12")])
  4365.  
  4366. ;; We have insns of the form shown by the first define_insn below.  If
  4367. ;; there is something inside the comparison operation, we must split it.
  4368. (define_split
  4369.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  4370.     (plus:SI (match_operator 1 "comparison_operator"
  4371.                  [(match_operand:SI 2 "" "")
  4372.                   (match_operand:SI 3
  4373.                             "reg_or_cint_operand" "")])
  4374.          (match_operand:SI 4 "gpc_reg_operand" "")))
  4375.    (clobber (match_operand:SI 5 "register_operand" ""))]
  4376.   "! gpc_reg_operand (operands[2], SImode)"
  4377.   [(set (match_dup 5) (match_dup 2))
  4378.    (set (match_dup 2) (plus:SI (match_op_dup 1 [(match_dup 2) (match_dup 3)])
  4379.                    (match_dup 4)))])
  4380.  
  4381. (define_insn ""
  4382.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r")
  4383.     (plus:SI (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
  4384.             (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I"))
  4385.          (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r,r")))
  4386.    (clobber (match_scratch:SI 4 "=&r,&r,&r,&r,&r"))]
  4387.   ""
  4388.   "@
  4389.    xor %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3
  4390.    {sfi|subfic} %4,%1,0\;{aze|addze} %0,%3
  4391.    {xoril|xori} %4,%1,%b2\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3
  4392.    {xoriu|xoris} %4,%1,%u2\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3
  4393.    {sfi|subfic} %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3"
  4394.   [(set_attr "length" "12,8,12,12,12")])
  4395.  
  4396. (define_insn ""
  4397.   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x,x,x")
  4398.     (compare:CC 
  4399.      (plus:SI
  4400.       (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
  4401.          (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I"))
  4402.       (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r,r"))
  4403.      (const_int 0)))
  4404.    (clobber (match_scratch:SI 4 "=&r,&r,&r,&r,&r"))]
  4405.   ""
  4406.   "@
  4407.    xor %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
  4408.    {sfi|subfic} %4,%1,0\;{aze.|addze.} %0,%3
  4409.    {xoril|xori} %4,%1,%b2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
  4410.    {xoriu|xoris} %4,%1,%u2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
  4411.    {sfi|subfic} %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3"
  4412.   [(set_attr "type" "compare")
  4413.    (set_attr "length" "12,8,12,12,12")])
  4414.  
  4415. (define_insn ""
  4416.   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x,x,x,x")
  4417.     (compare:CC 
  4418.      (plus:SI
  4419.       (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
  4420.          (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I"))
  4421.       (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r,r"))
  4422.      (const_int 0)))
  4423.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r")
  4424.     (plus:SI (eq:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
  4425.    (clobber (match_scratch:SI 4 "=&r,&r,&r,&r,&r"))]
  4426.   ""
  4427.   "@
  4428.    xor %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3
  4429.    {sfi|subfic} %4,%1,0\;{aze.|addze.} %4,%3
  4430.    {xoril|xori} %4,%1,%b2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3
  4431.    {xoriu|xoris} %4,%1,%u2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3
  4432.    {sfi|subfic} %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3"
  4433.   [(set_attr "type" "compare")
  4434.    (set_attr "length" "12,8,12,12,12")])
  4435.  
  4436. (define_insn ""
  4437.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r")
  4438.     (neg:SI (eq:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r,r")
  4439.                (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I"))))]
  4440.   ""
  4441.   "@
  4442.    xor %0,%1,%2\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0
  4443.    {ai|addic} %0,%1,-1\;{sfe|subfe} %0,%0,%0
  4444.    {xoril|xori} %0,%1,%b2\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0
  4445.    {xoriu|xoris} %0,%1,%u2\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0
  4446.    {sfi|subfic} %0,%1,%2\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0"
  4447.    [(set_attr "length" "12,8,12,12,12")])
  4448.  
  4449. ;; This is what (plus (ne X (const_int 0)) Y) looks like.
  4450. (define_insn ""
  4451.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4452.     (plus:SI (lshiftrt:SI
  4453.           (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))
  4454.           (const_int 31))
  4455.          (match_operand:SI 2 "gpc_reg_operand" "r")))
  4456.    (clobber (match_scratch:SI 3 "=&r"))]
  4457.   ""
  4458.   "{ai|addic} %3,%1,-1\;{aze|addze} %0,%2"
  4459.   [(set_attr "length" "8")])
  4460.  
  4461. (define_insn ""
  4462.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  4463.     (compare:CC
  4464.      (plus:SI (lshiftrt:SI
  4465.            (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))
  4466.            (const_int 31))
  4467.           (match_operand:SI 2 "gpc_reg_operand" "r"))
  4468.      (const_int 0)))
  4469.    (clobber (match_scratch:SI 3 "=&r"))]
  4470.   ""
  4471.   "{ai|addic} %3,%1,-1\;{aze.|addze.} %3,%2"
  4472.   [(set_attr "type" "compare")
  4473.    (set_attr "length" "8")])
  4474.  
  4475. (define_insn ""
  4476.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  4477.     (compare:CC
  4478.      (plus:SI (lshiftrt:SI
  4479.            (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))
  4480.            (const_int 31))
  4481.           (match_operand:SI 2 "gpc_reg_operand" "r"))
  4482.      (const_int 0)))
  4483.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4484.     (plus:SI (lshiftrt:SI (neg:SI (abs:SI (match_dup 1))) (const_int 31))
  4485.          (match_dup 2)))
  4486.    (clobber (match_scratch:SI 3 "=&r"))]
  4487.   ""
  4488.   "{ai|addic} %3,%1,-1\;{aze.|addze.} %0,%2"
  4489.   [(set_attr "type" "compare")
  4490.    (set_attr "length" "8")])
  4491.  
  4492. (define_insn ""
  4493.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  4494.     (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  4495.            (match_operand:SI 2 "reg_or_short_operand" "r,O")))
  4496.    (clobber (match_scratch:SI 3 "=r,X"))]
  4497.   "TARGET_POWER"
  4498.   "@
  4499.    doz %3,%2,%1\;{sfi|subfic} %0,%3,0\;{ae|adde} %0,%0,%3
  4500.    {ai|addic} %0,%1,-1\;{aze|addze} %0,%0\;{sri|srwi} %0,%0,31"
  4501.   [(set_attr "length" "12")])
  4502.  
  4503. (define_insn ""
  4504.   [(set (match_operand:CC 4 "cc_reg_operand" "=x,x")
  4505.     (compare:CC
  4506.      (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  4507.         (match_operand:SI 2 "reg_or_short_operand" "r,O"))
  4508.      (const_int 0)))
  4509.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  4510.     (le:SI (match_dup 1) (match_dup 2)))
  4511.    (clobber (match_scratch:SI 3 "=r,X"))]
  4512.   "TARGET_POWER"
  4513.   "@
  4514.    doz %3,%2,%1\;{sfi|subfic} %0,%3,0\;{ae.|adde.} %0,%0,%3
  4515.    {ai|addic} %0,%1,-1\;{aze|addze} %0,%0\;{sri.|srwi.} %0,%0,31"
  4516.   [(set_attr "type" "delayed_compare,compare")
  4517.    (set_attr "length" "12")])
  4518.  
  4519. (define_insn ""
  4520.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  4521.     (plus:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  4522.             (match_operand:SI 2 "reg_or_short_operand" "r,O"))
  4523.          (match_operand:SI 3 "gpc_reg_operand" "r,r")))
  4524.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  4525.   "TARGET_POWER"
  4526.   "@
  4527.    doz %4,%2,%1\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3
  4528.    {srai|srawi} %4,%1,31\;{sf|subfc} %4,%1,%4\;{aze|addze} %0,%3"
  4529.   [(set_attr "length" "12")])
  4530.  
  4531. (define_insn ""
  4532.   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
  4533.     (compare:CC
  4534.      (plus:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  4535.              (match_operand:SI 2 "reg_or_short_operand" "r,O"))
  4536.           (match_operand:SI 3 "gpc_reg_operand" "r,r"))
  4537.      (const_int 0)))
  4538.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  4539.   "TARGET_POWER"
  4540.   "@
  4541.    doz %4,%2,%1\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
  4542.    {srai|srawi} %4,%1,31\;{sf|subfc} %4,%1,%4\;{aze.|addze.} %4,%3"
  4543.   [(set_attr "type" "compare")
  4544.    (set_attr "length" "12")])
  4545.  
  4546. (define_insn ""
  4547.   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x")
  4548.     (compare:CC
  4549.      (plus:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  4550.              (match_operand:SI 2 "reg_or_short_operand" "r,O"))
  4551.           (match_operand:SI 3 "gpc_reg_operand" "r,r"))
  4552.      (const_int 0)))
  4553.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  4554.     (plus:SI (le:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
  4555.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  4556.   "TARGET_POWER"
  4557.   "@
  4558.    doz %4,%2,%1\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3
  4559.    {srai|srawi} %4,%1,31\;{sf|subfc} %4,%1,%4\;{aze.|addze.} %0,%3"
  4560.   [(set_attr "type" "compare")
  4561.    (set_attr "length" "12")])
  4562.  
  4563. (define_insn ""
  4564.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  4565.     (neg:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  4566.                (match_operand:SI 2 "reg_or_short_operand" "r,O"))))]
  4567.   "TARGET_POWER"
  4568.   "@
  4569.    doz %0,%2,%1\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0
  4570.    {ai|addic} %0,%1,-1\;{aze|addze} %0,%0\;{srai|srawi} %0,%0,31"
  4571.   [(set_attr "length" "12")])
  4572.  
  4573. (define_insn ""
  4574.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4575.     (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  4576.         (match_operand:SI 2 "reg_or_short_operand" "rI")))]
  4577.   ""
  4578.   "{sf%I2|subf%I2c} %0,%1,%2\;{cal %0,0(0)|li %0,0}\;{ae|adde} %0,%0,%0"
  4579.   [(set_attr "length" "12")])
  4580.  
  4581. (define_insn ""
  4582.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  4583.     (compare:CC
  4584.      (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  4585.          (match_operand:SI 2 "reg_or_short_operand" "rI"))
  4586.      (const_int 0)))
  4587.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4588.     (leu:SI (match_dup 1) (match_dup 2)))]
  4589.    ""
  4590.   "{sf%I2|subf%I2c} %0,%1,%2\;{cal %0,0(0)|li %0,0}\;{ae.|adde.} %0,%0,%0"
  4591.   [(set_attr "type" "compare")
  4592.    (set_attr "length" "12")])
  4593.  
  4594. (define_insn ""
  4595.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4596.     (plus:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  4597.              (match_operand:SI 2 "reg_or_short_operand" "rI"))
  4598.          (match_operand:SI 3 "gpc_reg_operand" "r")))
  4599.    (clobber (match_scratch:SI 4 "=&r"))]
  4600.   ""
  4601.   "{sf%I2|subf%I2c} %4,%1,%2\;{aze|addze} %0,%3"
  4602.   [(set_attr "length" "8")])
  4603.  
  4604. (define_insn ""
  4605.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  4606.     (compare:CC
  4607.      (plus:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  4608.               (match_operand:SI 2 "reg_or_short_operand" "rI"))
  4609.           (match_operand:SI 3 "gpc_reg_operand" "r"))
  4610.      (const_int 0)))
  4611.    (clobber (match_scratch:SI 4 "=&r"))]
  4612.   ""
  4613.   "{sf%I2|subf%I2c} %4,%1,%2\;{aze.|addze.} %4,%3"
  4614.   [(set_attr "type" "compare")
  4615.    (set_attr "length" "8")])
  4616.  
  4617. (define_insn ""
  4618.   [(set (match_operand:CC 5 "cc_reg_operand" "=x")
  4619.     (compare:CC
  4620.      (plus:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  4621.               (match_operand:SI 2 "reg_or_short_operand" "rI"))
  4622.           (match_operand:SI 3 "gpc_reg_operand" "r"))
  4623.      (const_int 0)))
  4624.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4625.     (plus:SI (leu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
  4626.    (clobber (match_scratch:SI 4 "=&r"))]
  4627.   ""
  4628.   "{sf%I2|subf%I2c} %4,%1,%2\;{aze.|addze.} %0,%3"
  4629.   [(set_attr "type" "compare")
  4630.    (set_attr "length" "8")])
  4631.  
  4632. (define_insn ""
  4633.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4634.     (neg:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  4635.             (match_operand:SI 2 "reg_or_short_operand" "rI"))))]
  4636.   ""
  4637.   "{sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0\;nand %0,%0,%0"
  4638.    [(set_attr "length" "12")])
  4639.  
  4640. (define_insn ""
  4641.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4642.     (and:SI (neg:SI
  4643.          (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  4644.              (match_operand:SI 2 "reg_or_short_operand" "rI")))
  4645.         (match_operand:SI 3 "gpc_reg_operand" "r")))
  4646.    (clobber (match_scratch:SI 4 "=&r"))]
  4647.   ""
  4648.   "{sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;andc %0,%3,%4"
  4649.   [(set_attr "length" "12")])
  4650.  
  4651. (define_insn ""
  4652.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  4653.     (compare:CC
  4654.      (and:SI (neg:SI
  4655.           (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  4656.               (match_operand:SI 2 "reg_or_short_operand" "rI")))
  4657.          (match_operand:SI 3 "gpc_reg_operand" "r"))
  4658.      (const_int 0)))
  4659.    (clobber (match_scratch:SI 4 "=&r"))]
  4660.   ""
  4661.   "{sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;andc. %4,%3,%4"
  4662.   [(set_attr "type" "compare")
  4663.    (set_attr "length" "12")])
  4664.  
  4665. (define_insn ""
  4666.   [(set (match_operand:CC 5 "cc_reg_operand" "=x")
  4667.     (compare:CC
  4668.      (and:SI (neg:SI
  4669.           (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  4670.               (match_operand:SI 2 "reg_or_short_operand" "rI")))
  4671.          (match_operand:SI 3 "gpc_reg_operand" "r"))
  4672.      (const_int 0)))
  4673.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4674.     (and:SI (neg:SI (leu:SI (match_dup 1) (match_dup 2))) (match_dup 3)))
  4675.    (clobber (match_scratch:SI 4 "=&r"))]
  4676.   ""
  4677.   "{sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;andc. %0,%3,%4"
  4678.   [(set_attr "type" "compare")
  4679.    (set_attr "length" "12")])
  4680.  
  4681. (define_insn ""
  4682.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4683.     (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  4684.            (match_operand:SI 2 "reg_or_short_operand" "rI")))]
  4685.   "TARGET_POWER"
  4686.   "doz%I2 %0,%1,%2\;nabs %0,%0\;{sri|srwi} %0,%0,31"
  4687.    [(set_attr "length" "12")])
  4688.  
  4689. (define_insn ""
  4690.   [(set (match_operand:SI 3 "cc_reg_operand" "=x")
  4691.     (compare:CC
  4692.      (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  4693.         (match_operand:SI 2 "reg_or_short_operand" "rI"))
  4694.      (const_int 0)))
  4695.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4696.     (lt:SI (match_dup 1) (match_dup 2)))]
  4697.   "TARGET_POWER"
  4698.   "doz%I2 %0,%1,%2\;nabs %0,%0\;{sri.|srwi.} %0,%0,31"
  4699.   [(set_attr "type" "delayed_compare")
  4700.    (set_attr "length" "12")])
  4701.  
  4702. (define_insn ""
  4703.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4704.     (plus:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  4705.             (match_operand:SI 2 "reg_or_short_operand" "rI"))
  4706.          (match_operand:SI 3 "gpc_reg_operand" "r")))
  4707.    (clobber (match_scratch:SI 4 "=&r"))]
  4708.   "TARGET_POWER"
  4709.   "doz%I2 %4,%1,%2\;{ai|addic} %4,%4,-1\;{aze|addze} %0,%3"
  4710.   [(set_attr "length" "12")])
  4711.  
  4712. (define_insn ""
  4713.   [(set (match_operand:SI 0 "cc_reg_operand" "=x")
  4714.     (compare:CC
  4715.      (plus:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  4716.              (match_operand:SI 2 "reg_or_short_operand" "rI"))
  4717.           (match_operand:SI 3 "gpc_reg_operand" "r"))
  4718.      (const_int 0)))
  4719.    (clobber (match_scratch:SI 4 "=&r"))]
  4720.   "TARGET_POWER"
  4721.   "doz%I2 %4,%1,%2\;{ai|addic} %4,%4,-1\;{aze.|addze.} %4,%3"
  4722.   [(set_attr "type" "compare")
  4723.    (set_attr "length" "12")])
  4724.  
  4725. (define_insn ""
  4726.   [(set (match_operand:SI 5 "cc_reg_operand" "=x")
  4727.     (compare:CC
  4728.      (plus:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  4729.              (match_operand:SI 2 "reg_or_short_operand" "rI"))
  4730.           (match_operand:SI 3 "gpc_reg_operand" "r"))
  4731.      (const_int 0)))
  4732.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4733.     (plus:SI (lt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
  4734.    (clobber (match_scratch:SI 4 "=&r"))]
  4735.   "TARGET_POWER"
  4736.   "doz%I2 %4,%1,%2\;{ai|addic} %4,%4,-1\;{aze.|addze.} %0,%3"
  4737.   [(set_attr "type" "compare")
  4738.    (set_attr "length" "12")])
  4739.  
  4740. (define_insn ""
  4741.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4742.     (neg:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  4743.                (match_operand:SI 2 "reg_or_short_operand" "rI"))))]
  4744.   "TARGET_POWER"
  4745.   "doz%I2 %0,%1,%2\;nabs %0,%0\;{srai|srawi} %0,%0,31"
  4746.   [(set_attr "length" "12")])
  4747.  
  4748. (define_insn ""
  4749.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  4750.     (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  4751.         (match_operand:SI 2 "reg_or_neg_short_operand" "r,P")))]
  4752.   ""
  4753.   "@
  4754.    {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0\;neg %0,%0
  4755.    {ai|addic} %0,%1,%n2\;{sfe|subfe} %0,%0,%0\;neg %0,%0"
  4756.   [(set_attr "length" "12")])
  4757.  
  4758. (define_insn ""
  4759.   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x")
  4760.     (compare:CC
  4761.      (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  4762.          (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
  4763.      (const_int 0)))
  4764.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  4765.     (ltu:SI (match_dup 1) (match_dup 2)))]
  4766.   ""
  4767.   "@
  4768.    {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0\;neg. %0,%0
  4769.    {ai|addic} %0,%1,%n2\;{sfe|subfe} %0,%0,%0\;neg. %0,%0"
  4770.   [(set_attr "type" "compare")
  4771.    (set_attr "length" "12")])
  4772.  
  4773. (define_insn ""
  4774.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
  4775.     (plus:SI (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
  4776.              (match_operand:SI 2 "reg_or_neg_short_operand" "r,r,P,P"))
  4777.          (match_operand:SI 3 "reg_or_short_operand" "r,I,r,I")))
  4778.    (clobber (match_scratch:SI 4 "=&r,r,&r,r"))]
  4779.   ""
  4780.   "@
  4781.   {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3
  4782.   {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3
  4783.   {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3
  4784.   {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3"
  4785.  [(set_attr "length" "12")])
  4786.  
  4787. (define_insn ""
  4788.   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
  4789.     (compare:CC
  4790.      (plus:SI (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  4791.               (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
  4792.           (match_operand:SI 3 "gpc_reg_operand" "r,r"))
  4793.      (const_int 0)))
  4794.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  4795.   ""
  4796.   "@
  4797.    {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %4,%4,%3
  4798.    {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %4,%4,%3"
  4799.   [(set_attr "type" "compare")
  4800.    (set_attr "length" "12")])
  4801.  
  4802. (define_insn ""
  4803.   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x")
  4804.     (compare:CC
  4805.      (plus:SI (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  4806.               (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
  4807.           (match_operand:SI 3 "gpc_reg_operand" "r,r"))
  4808.      (const_int 0)))
  4809.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  4810.     (plus:SI (ltu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
  4811.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  4812.   ""
  4813.   "@
  4814.    {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %0,%4,%3
  4815.    {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %0,%4,%3"
  4816.   [(set_attr "type" "compare")
  4817.    (set_attr "length" "12")])
  4818.  
  4819. (define_insn ""
  4820.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  4821.     (neg:SI (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  4822.             (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))))]
  4823.   ""
  4824.   "@
  4825.    {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0
  4826.    {ai|addic} %0,%1,%n2\;{sfe|subfe} %0,%0,%0"
  4827.   [(set_attr "length" "8")])
  4828.  
  4829. (define_insn ""
  4830.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4831.     (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  4832.            (match_operand:SI 2 "reg_or_short_operand" "rI")))
  4833.    (clobber (match_scratch:SI 3 "=r"))]
  4834.   "TARGET_POWER"
  4835.   "doz%I2 %3,%1,%2\;{sfi|subfic} %0,%3,0\;{ae|adde} %0,%0,%3"
  4836.    [(set_attr "length" "12")])
  4837.  
  4838. (define_insn ""
  4839.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  4840.     (compare:CC
  4841.      (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  4842.         (match_operand:SI 2 "reg_or_short_operand" "rI"))
  4843.      (const_int 0)))
  4844.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4845.     (ge:SI (match_dup 1) (match_dup 2)))
  4846.    (clobber (match_scratch:SI 3 "=r"))]
  4847.   "TARGET_POWER"
  4848.   "doz%I2 %3,%1,%2\;{sfi|subfic} %0,%3,0\;{ae.|adde.} %0,%0,%3"
  4849.   [(set_attr "type" "compare")
  4850.    (set_attr "length" "12")])
  4851.  
  4852. (define_insn ""
  4853.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4854.     (plus:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  4855.             (match_operand:SI 2 "reg_or_short_operand" "rI"))
  4856.          (match_operand:SI 3 "gpc_reg_operand" "r")))
  4857.    (clobber (match_scratch:SI 4 "=&r"))]
  4858.   "TARGET_POWER"
  4859.   "doz%I2 %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3"
  4860.   [(set_attr "length" "12")])
  4861.  
  4862. (define_insn ""
  4863.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  4864.     (compare:CC
  4865.      (plus:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  4866.              (match_operand:SI 2 "reg_or_short_operand" "rI"))
  4867.           (match_operand:SI 3 "gpc_reg_operand" "r"))
  4868.      (const_int 0)))
  4869.    (clobber (match_scratch:SI 4 "=&r"))]
  4870.   "TARGET_POWER"
  4871.   "doz%I2 %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3"
  4872.   [(set_attr "type" "compare")
  4873.    (set_attr "length" "12")])
  4874.  
  4875. (define_insn ""
  4876.   [(set (match_operand:CC 5 "cc_reg_operand" "=x")
  4877.     (compare:CC
  4878.      (plus:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  4879.              (match_operand:SI 2 "reg_or_short_operand" "rI"))
  4880.           (match_operand:SI 3 "gpc_reg_operand" "r"))
  4881.      (const_int 0)))
  4882.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4883.     (plus:SI (ge:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
  4884.    (clobber (match_scratch:SI 4 "=&r"))]
  4885.   "TARGET_POWER"
  4886.   "doz%I2 %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3"
  4887.   [(set_attr "type" "compare")
  4888.    (set_attr "length" "12")])
  4889.  
  4890. (define_insn ""
  4891.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4892.     (neg:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  4893.                (match_operand:SI 2 "reg_or_short_operand" "rI"))))]
  4894.   "TARGET_POWER"
  4895.   "doz%I2 %0,%1,%2\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0"
  4896.   [(set_attr "length" "12")])
  4897.  
  4898. ;; This is (and (neg (ge X (const_int 0))) Y).
  4899. (define_insn ""
  4900.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4901.     (and:SI (neg:SI
  4902.          (lshiftrt:SI
  4903.           (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  4904.           (const_int 31)))
  4905.         (match_operand:SI 2 "gpc_reg_operand" "r")))
  4906.    (clobber (match_scratch:SI 3 "=&r"))]
  4907.   ""
  4908.   "{srai|srawi} %3,%1,31\;andc %0,%2,%3"
  4909.   [(set_attr "length" "8")])
  4910.  
  4911. (define_insn ""
  4912.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  4913.     (compare:CC
  4914.      (and:SI (neg:SI
  4915.           (lshiftrt:SI
  4916.            (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  4917.            (const_int 31)))
  4918.          (match_operand:SI 2 "gpc_reg_operand" "r"))
  4919.      (const_int 0)))
  4920.    (clobber (match_scratch:SI 3 "=&r"))]
  4921.   ""
  4922.   "{srai|srawi} %3,%1,31\;andc. %3,%2,%3"
  4923.   [(set_attr "type" "compare")
  4924.    (set_attr "length" "8")])
  4925.  
  4926. (define_insn ""
  4927.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  4928.     (compare:CC
  4929.      (and:SI (neg:SI
  4930.           (lshiftrt:SI
  4931.            (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  4932.            (const_int 31)))
  4933.          (match_operand:SI 2 "gpc_reg_operand" "r"))
  4934.      (const_int 0)))
  4935.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  4936.     (and:SI (neg:SI (lshiftrt:SI (not:SI (match_dup 1))
  4937.                      (const_int 31)))
  4938.         (match_dup 2)))
  4939.    (clobber (match_scratch:SI 3 "=&r"))]
  4940.   ""
  4941.   "{srai|srawi} %3,%1,31\;andc. %0,%2,%3"
  4942.   [(set_attr "type" "compare")
  4943.    (set_attr "length" "8")])
  4944.  
  4945. (define_insn ""
  4946.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  4947.     (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  4948.         (match_operand:SI 2 "reg_or_neg_short_operand" "r,P")))]
  4949.   ""
  4950.   "@
  4951.    {sf|subfc} %0,%2,%1\;{cal %0,0(0)|li %0,0}\;{ae|adde} %0,%0,%0
  4952.    {ai|addic} %0,%1,%n2\;{cal %0,0(0)|li %0,0}\;{ae|adde} %0,%0,%0"
  4953.   [(set_attr "length" "12")])
  4954.  
  4955. (define_insn ""
  4956.   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x")
  4957.     (compare:CC
  4958.      (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  4959.          (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
  4960.      (const_int 0)))
  4961.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  4962.     (geu:SI (match_dup 1) (match_dup 2)))]
  4963.   ""
  4964.   "@
  4965.    {sf|subfc} %0,%2,%1\;{cal %0,0(0)|li %0,0}\;{ae.|adde.} %0,%0,%0
  4966.    {ai|addic} %0,%1,%n2\;{cal %0,0(0)|li %0,0}\;{ae.|adde.} %0,%0,%0"
  4967.   [(set_attr "type" "compare")
  4968.    (set_attr "length" "12")])
  4969.  
  4970. (define_insn ""
  4971.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  4972.     (plus:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  4973.              (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
  4974.          (match_operand:SI 3 "gpc_reg_operand" "r,r")))
  4975.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  4976.   ""
  4977.   "@
  4978.    {sf|subfc} %4,%2,%1\;{aze|addze} %0,%3
  4979.    {ai|addic} %4,%1,%n2\;{aze|addze} %0,%3"
  4980.   [(set_attr "length" "8")])
  4981.  
  4982. (define_insn ""
  4983.   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
  4984.     (compare:CC
  4985.      (plus:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  4986.               (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
  4987.           (match_operand:SI 3 "gpc_reg_operand" "r,r"))
  4988.      (const_int 0)))
  4989.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  4990.   ""
  4991.   "@
  4992.    {sf|subfc} %4,%2,%1\;{aze.|addze.} %4,%3
  4993.    {ai|addic} %4,%1,%n2\;{aze.|addze.} %4,%3"
  4994.   [(set_attr "type" "compare")
  4995.    (set_attr "length" "8")])
  4996.  
  4997. (define_insn ""
  4998.   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x")
  4999.     (compare:CC
  5000.      (plus:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5001.               (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
  5002.           (match_operand:SI 3 "gpc_reg_operand" "r,r"))
  5003.      (const_int 0)))
  5004.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  5005.     (plus:SI (geu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
  5006.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  5007.   ""
  5008.   "@
  5009.    {sf|subfc} %4,%2,%1\;{aze.|addze.} %0,%3
  5010.    {ai|addic} %4,%1,%n2\;{aze.|addze.} %4,%3"
  5011.   [(set_attr "type" "compare")
  5012.    (set_attr "length" "8")])
  5013.  
  5014. (define_insn ""
  5015.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  5016.     (neg:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5017.             (match_operand:SI 2 "reg_or_short_operand" "r,I"))))]
  5018.   ""
  5019.   "@
  5020.    {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0\;nand %0,%0,%0
  5021.    {sfi|subfic} %0,%1,-1\;a%I2 %0,%0,%2\;{sfe|subfe} %0,%0,%0"
  5022.   [(set_attr "length" "12")])
  5023.  
  5024. (define_insn ""
  5025.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  5026.     (and:SI (neg:SI
  5027.          (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5028.              (match_operand:SI 2 "reg_or_neg_short_operand" "r,P")))
  5029.         (match_operand:SI 3 "gpc_reg_operand" "r,r")))
  5030.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  5031.   ""
  5032.   "@
  5033.    {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;andc %0,%3,%4
  5034.    {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;andc %0,%3,%4"
  5035.   [(set_attr "length" "12")])
  5036.  
  5037. (define_insn ""
  5038.   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
  5039.     (compare:CC
  5040.      (and:SI (neg:SI
  5041.           (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5042.               (match_operand:SI 2 "reg_or_neg_short_operand" "r,P")))
  5043.          (match_operand:SI 3 "gpc_reg_operand" "r,r"))
  5044.      (const_int 0)))
  5045.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  5046.   ""
  5047.   "@
  5048.    {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;andc. %4,%3,%4
  5049.    {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;andc. %4,%3,%4"
  5050.   [(set_attr "type" "compare")
  5051.    (set_attr "length" "12")])
  5052.  
  5053. (define_insn ""
  5054.   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x")
  5055.     (compare:CC
  5056.      (and:SI (neg:SI
  5057.           (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5058.               (match_operand:SI 2 "reg_or_neg_short_operand" "r,P")))
  5059.          (match_operand:SI 3 "gpc_reg_operand" "r,r"))
  5060.      (const_int 0)))
  5061.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  5062.     (and:SI (neg:SI (geu:SI (match_dup 1) (match_dup 2))) (match_dup 3)))
  5063.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  5064.   ""
  5065.   "@
  5066.    {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;andc. %0,%3,%4
  5067.    {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;andc. %0,%3,%4"
  5068.   [(set_attr "type" "compare")
  5069.    (set_attr "length" "12")])
  5070.  
  5071. (define_insn ""
  5072.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5073.     (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5074.            (const_int 0)))]
  5075.   ""
  5076.   "{sfi|subfic} %0,%1,0\;{ame|addme} %0,%0\;{sri|srwi} %0,%0,31"
  5077.   [(set_attr "length" "12")])
  5078.  
  5079. (define_insn ""
  5080.   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
  5081.     (compare:CC
  5082.      (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5083.         (const_int 0))
  5084.      (const_int 0)))
  5085.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5086.     (gt:SI (match_dup 1) (const_int 0)))]
  5087.   ""
  5088.   "{sfi|subfic} %0,%1,0\;{ame|addme} %0,%0\;{sri.|srwi.} %0,%0,31"
  5089.   [(set_attr "type" "delayed_compare")
  5090.    (set_attr "length" "12")])
  5091.  
  5092. (define_insn ""
  5093.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5094.     (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5095.            (match_operand:SI 2 "reg_or_short_operand" "r")))]
  5096.   "TARGET_POWER"
  5097.   "doz %0,%2,%1\;nabs %0,%0\;{sri|srwi} %0,%0,31"
  5098.   [(set_attr "length" "12")])
  5099.  
  5100. (define_insn ""
  5101.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  5102.     (compare:CC
  5103.      (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5104.         (match_operand:SI 2 "reg_or_short_operand" "r"))
  5105.      (const_int 0)))
  5106.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5107.     (gt:SI (match_dup 1) (match_dup 2)))]
  5108.   "TARGET_POWER"
  5109.   "doz %0,%2,%1\;nabs %0,%0\;{sri.|srwi.} %0,%0,31"
  5110.   [(set_attr "type" "delayed_compare")
  5111.    (set_attr "length" "12")])
  5112.  
  5113. (define_insn ""
  5114.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5115.     (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5116.             (const_int 0))
  5117.          (match_operand:SI 2 "gpc_reg_operand" "r")))
  5118.    (clobber (match_scratch:SI 3 "=&r"))]
  5119.   ""
  5120.   "{a|addc} %3,%1,%1\;{sfe|subfe} %3,%1,%3\;{aze|addze} %0,%2"
  5121.   [(set_attr "length" "12")])
  5122.  
  5123. (define_insn ""
  5124.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  5125.     (compare:CC
  5126.      (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5127.              (const_int 0))
  5128.           (match_operand:SI 2 "gpc_reg_operand" "r"))
  5129.      (const_int 0)))
  5130.    (clobber (match_scratch:SI 3 "=&r"))]
  5131.   ""
  5132.   "{a|addc} %3,%1,%1\;{sfe|subfe} %3,%1,%3\;{aze.|addze.} %0,%2"
  5133.   [(set_attr "type" "compare")
  5134.    (set_attr "length" "12")])
  5135.  
  5136. (define_insn ""
  5137.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  5138.     (compare:CC
  5139.      (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5140.              (const_int 0))
  5141.           (match_operand:SI 2 "gpc_reg_operand" "r"))
  5142.      (const_int 0)))
  5143.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5144.     (plus:SI (gt:SI (match_dup 1) (const_int 0)) (match_dup 2)))
  5145.    (clobber (match_scratch:SI 3 "=&r"))]
  5146.   ""
  5147.   "{a|addc} %3,%1,%1\;{sfe|subfe} %3,%1,%3\;{aze.|addze.} %3,%2"
  5148.   [(set_attr "type" "compare")
  5149.    (set_attr "length" "12")])
  5150.  
  5151. (define_insn ""
  5152.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5153.     (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5154.             (match_operand:SI 2 "reg_or_short_operand" "r"))
  5155.          (match_operand:SI 3 "gpc_reg_operand" "r")))
  5156.    (clobber (match_scratch:SI 4 "=&r"))]
  5157.   "TARGET_POWER"
  5158.   "doz %4,%2,%1\;{ai|addic} %4,%4,-1\;{aze|addze} %0,%3"
  5159.   [(set_attr "length" "12")])
  5160.  
  5161. (define_insn ""
  5162.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  5163.     (compare:CC
  5164.      (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5165.              (match_operand:SI 2 "reg_or_short_operand" "r"))
  5166.           (match_operand:SI 3 "gpc_reg_operand" "r"))
  5167.      (const_int 0)))
  5168.    (clobber (match_scratch:SI 4 "=&r"))]
  5169.   "TARGET_POWER"
  5170.   "doz %4,%2,%1\;{ai|addic} %4,%4,-1\;{aze.|addze.} %4,%3"
  5171.   [(set_attr "type" "compare")
  5172.    (set_attr "length" "12")])
  5173.  
  5174. (define_insn ""
  5175.   [(set (match_operand:CC 5 "cc_reg_operand" "=x")
  5176.     (compare:CC
  5177.      (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5178.              (match_operand:SI 2 "reg_or_short_operand" "r"))
  5179.           (match_operand:SI 3 "gpc_reg_operand" "r"))
  5180.      (const_int 0)))
  5181.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5182.     (plus:SI (gt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
  5183.    (clobber (match_scratch:SI 4 "=&r"))]
  5184.   "TARGET_POWER"
  5185.   "doz %4,%2,%1\;{ai|addic} %4,%4,-1\;{aze.|addze.} %0,%3"
  5186.   [(set_attr "type" "compare")
  5187.    (set_attr "length" "12")])
  5188.  
  5189. (define_insn ""
  5190.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5191.     (neg:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5192.                (const_int 0))))]
  5193.   ""
  5194.   "{sfi|subfic} %0,%1,0\;{ame|addme} %0,%0\;{srai|srawi} %0,%0,31"
  5195.   [(set_attr "length" "12")])
  5196.  
  5197. (define_insn ""
  5198.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5199.     (neg:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5200.                (match_operand:SI 2 "reg_or_short_operand" "r"))))]
  5201.   "TARGET_POWER"
  5202.   "doz %0,%2,%1\;nabs %0,%0\;{srai|srawi} %0,%0,31"
  5203.   [(set_attr "length" "12")])
  5204.  
  5205. (define_insn ""
  5206.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5207.     (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5208.         (match_operand:SI 2 "reg_or_short_operand" "rI")))]
  5209.   ""
  5210.   "{sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0\;neg %0,%0"
  5211.   [(set_attr "length" "12")])
  5212.  
  5213. (define_insn ""
  5214.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  5215.     (compare:CC
  5216.      (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5217.          (match_operand:SI 2 "reg_or_short_operand" "rI"))
  5218.      (const_int 0)))
  5219.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5220.     (gtu:SI (match_dup 1) (match_dup 2)))]
  5221.   ""
  5222.   "{sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0\;neg. %0,%0"
  5223.   [(set_attr "type" "compare")
  5224.    (set_attr "length" "12")])
  5225.  
  5226. (define_insn ""
  5227.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r")
  5228.     (plus:SI (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r")
  5229.              (match_operand:SI 2 "reg_or_short_operand" "I,r,rI"))
  5230.          (match_operand:SI 3 "reg_or_short_operand" "r,r,I")))
  5231.    (clobber (match_scratch:SI 4 "=&r,&r,&r"))]
  5232.   ""
  5233.   "@
  5234.    {ai|addic} %4,%1,%k2\;{aze|addze} %0,%3
  5235.    {sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3
  5236.    {sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3"
  5237.   [(set_attr "length" "8,12,12")])
  5238.  
  5239. (define_insn ""
  5240.   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
  5241.     (compare:CC
  5242.      (plus:SI (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5243.               (match_operand:SI 2 "reg_or_short_operand" "I,r"))
  5244.           (match_operand:SI 3 "gpc_reg_operand" "r,r"))
  5245.      (const_int 0)))
  5246.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  5247.   ""
  5248.   "@
  5249.    {ai|addic} %4,%1,%k2\;{aze.|addze.} %0,%3
  5250.    {sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %0,%4,%3"
  5251.   [(set_attr "type" "compare")
  5252.    (set_attr "length" "8,12")])
  5253.  
  5254. (define_insn ""
  5255.   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x")
  5256.     (compare:CC
  5257.      (plus:SI (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5258.               (match_operand:SI 2 "reg_or_short_operand" "I,r"))
  5259.           (match_operand:SI 3 "gpc_reg_operand" "r,r"))
  5260.      (const_int 0)))
  5261.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  5262.     (plus:SI (gtu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
  5263.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  5264.   ""
  5265.   "@
  5266.    {ai|addic} %4,%1,%k2\;{aze.|addze.} %0,%3
  5267.    {sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %0,%4,%3"
  5268.   [(set_attr "type" "compare")
  5269.    (set_attr "length" "8,12")])
  5270.  
  5271. (define_insn ""
  5272.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5273.     (neg:SI (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5274.             (match_operand:SI 2 "reg_or_short_operand" "rI"))))]
  5275.   ""
  5276.   "{sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0"
  5277.   [(set_attr "length" "8")])
  5278.  
  5279. ;; Define both directions of branch and return.  If we need a reload
  5280. ;; register, we'd rather use CR0 since it is much easier to copy a
  5281. ;; register CC value to there.
  5282.  
  5283. (define_insn ""
  5284.   [(set (pc)
  5285.     (if_then_else (match_operator 1 "branch_comparison_operator"
  5286.                       [(match_operand 2
  5287.                               "cc_reg_operand" "x,?y")
  5288.                        (const_int 0)])
  5289.               (label_ref (match_operand 0 "" ""))
  5290.               (pc)))]
  5291.   ""
  5292.   "*
  5293. {
  5294.   if (get_attr_length (insn) == 8)
  5295.     return \"%C1bc %t1,%j1,%l0\";
  5296.   else
  5297.     return \"%C1bc %T1,%j1,$+8\;b %l0\";
  5298. }"
  5299.   [(set_attr "type" "branch")])
  5300.  
  5301.  
  5302. (define_insn ""
  5303.   [(set (pc)
  5304.     (if_then_else (match_operator 0 "branch_comparison_operator"
  5305.                       [(match_operand 1
  5306.                               "cc_reg_operand" "x,?y")
  5307.                        (const_int 0)])
  5308.               (return)
  5309.               (pc)))]
  5310.   "direct_return ()"
  5311.   "{%C0bcr|%C0bclr} %t0,%j0"
  5312.   [(set_attr "length" "8")])
  5313.  
  5314. (define_insn ""
  5315.   [(set (pc)
  5316.     (if_then_else (match_operator 1 "branch_comparison_operator"
  5317.                       [(match_operand 2
  5318.                               "cc_reg_operand" "x,?y")
  5319.                        (const_int 0)])
  5320.               (pc)
  5321.               (label_ref (match_operand 0 "" ""))))]
  5322.   ""
  5323.   "*
  5324. {
  5325.   if (get_attr_length (insn) == 8)
  5326.     return \"%C1bc %T1,%j1,%l0\";
  5327.   else
  5328.     return \"%C1bc %t1,%j1,$+8\;b %l0\";
  5329. }"
  5330.   [(set_attr "type" "branch")])
  5331.  
  5332. (define_insn ""
  5333.   [(set (pc)
  5334.     (if_then_else (match_operator 0 "branch_comparison_operator"
  5335.                       [(match_operand 1
  5336.                               "cc_reg_operand" "x,?y")
  5337.                        (const_int 0)])
  5338.               (pc)
  5339.               (return)))]
  5340.   "direct_return ()"
  5341.   "{%C0bcr|%C0bclr} %T0,%j0"
  5342.   [(set_attr "length" "8")])
  5343.  
  5344. ;; Unconditional branch and return.
  5345.  
  5346. (define_insn "jump"
  5347.   [(set (pc)
  5348.     (label_ref (match_operand 0 "" "")))]
  5349.   ""
  5350.   "b %l0")
  5351.  
  5352. (define_insn "return"
  5353.   [(return)]
  5354.   "direct_return ()"
  5355.   "{br|blr}")
  5356.  
  5357. (define_insn "indirect_jump"
  5358.   [(set (pc) (match_operand:SI 0 "register_operand" "c,l"))]
  5359.   ""
  5360.   "@
  5361.    bctr
  5362.    {br|blr}")
  5363.  
  5364. ;; Table jump for switch statements:
  5365. (define_expand "tablejump"
  5366.   [(set (match_dup 3)
  5367.     (plus:SI (match_operand:SI 0 "" "")
  5368.          (match_dup 2)))
  5369.    (parallel [(set (pc) (match_dup 3))
  5370.           (use (label_ref (match_operand 1 "" "")))])]
  5371.   ""
  5372.   "
  5373. { operands[0] = force_reg (SImode, operands[0]);
  5374.   operands[2] = force_reg (SImode, gen_rtx (LABEL_REF, VOIDmode, operands[1]));
  5375.   operands[3] = gen_reg_rtx (SImode);
  5376. }")
  5377.  
  5378. (define_insn ""
  5379.   [(set (pc)
  5380.     (match_operand:SI 0 "register_operand" "c,l"))
  5381.    (use (label_ref (match_operand 1 "" "")))]
  5382.   ""
  5383.   "@
  5384.    bctr
  5385.    {br|blr}")
  5386.  
  5387. (define_insn "nop"
  5388.   [(const_int 0)]
  5389.   ""
  5390.   "{cror 0,0,0|nop}")
  5391.  
  5392. ;; Define the subtract-one-and-jump insns, starting with the template 
  5393. ;; so loop.c knows what to generate.
  5394.  
  5395. (define_expand "decrement_and_branchsi"
  5396.   [(parallel [(set (pc) (if_then_else (ne (match_operand:SI 0 "register_operand" "c")
  5397.                       (const_int 1))
  5398.                       (label_ref (match_operand 1 "" ""))
  5399.                       (pc)))
  5400.           (set (match_dup 0) (plus:SI (match_dup 0) (const_int -1)))])]
  5401.   ""
  5402.   "")
  5403.  
  5404. ;; We need to be able to do this for any operand, including MEM, or we
  5405. ;; will cause reload to blow up since we don't allow output reloads on
  5406. ;; JUMP_INSNs. 
  5407. (define_insn ""
  5408.   [(set (pc)
  5409.     (if_then_else (ne (match_operand:SI 1 "register_operand" "0,*r,*r")
  5410.               (const_int 1))
  5411.               (label_ref (match_operand 2 "" ""))
  5412.               (pc)))
  5413.    (set (match_operand:SI 0 "register_operand" "=c,*r,m*q*c*l")
  5414.     (plus:SI (match_dup 1) (const_int -1)))
  5415.    (clobber (match_scratch:CC 3 "=X,&x,&x"))
  5416.    (clobber (match_scratch:SI 4 "=X,X,r"))]
  5417.   ""
  5418.   "*
  5419. {
  5420.   if (which_alternative != 0)
  5421.     return \"#\";
  5422.   else if (get_attr_length (insn) == 8)
  5423.     return \"{bdn|bdnz} %l2\";
  5424.   else
  5425.     return \"bdz $+8\;b %l2\";
  5426. }"
  5427.   [(set_attr "type" "branch")
  5428.    (set_attr "length" "*,12,16")])
  5429.                    
  5430. ;; Similar, but we can use GE since we have a REG_NONNEG.
  5431. (define_insn ""
  5432.   [(set (pc)
  5433.     (if_then_else (ge (match_operand:SI 1 "register_operand" "0,*r,*r")
  5434.               (const_int 0))
  5435.               (label_ref (match_operand 2 "" ""))
  5436.               (pc)))
  5437.    (set (match_operand:SI 0 "register_operand" "=c,*r,m*q*c*l")
  5438.     (plus:SI (match_dup 1) (const_int -1)))
  5439.    (clobber (match_scratch:CC 3 "=X,&x,&X"))
  5440.    (clobber (match_scratch:SI 4 "=X,X,r"))]
  5441.   "find_reg_note (insn, REG_NONNEG, 0)"
  5442.   "*
  5443. {
  5444.   if (which_alternative != 0)
  5445.     return \"#\";
  5446.   else if (get_attr_length (insn) == 8)
  5447.     return \"{bdn|bdnz} %l2\";
  5448.   else
  5449.     return \"bdz $+8\;b %l2\";
  5450. }"
  5451.   [(set_attr "type" "branch")
  5452.    (set_attr "length" "*,12,16")])
  5453.                    
  5454. (define_insn ""
  5455.   [(set (pc)
  5456.     (if_then_else (eq (match_operand:SI 1 "register_operand" "0,*r,*r")
  5457.               (const_int 1))
  5458.               (label_ref (match_operand 2 "" ""))
  5459.               (pc)))
  5460.    (set (match_operand:SI 0 "register_operand" "=c,*r,m*q*c*l")
  5461.     (plus:SI (match_dup 1) (const_int -1)))
  5462.    (clobber (match_scratch:CC 3 "=X,&x,&x"))
  5463.    (clobber (match_scratch:SI 4 "=X,X,r"))]
  5464.   ""
  5465.   "*
  5466. {
  5467.   if (which_alternative != 0)
  5468.     return \"#\";
  5469.   else if (get_attr_length (insn) == 8)
  5470.     return \"bdz %l2\";
  5471.   else
  5472.     return \"{bdn|bdnz} $+8\;b %l2\";
  5473. }"
  5474.   [(set_attr "type" "branch")
  5475.    (set_attr "length" "*,12,16")])
  5476.  
  5477. (define_split
  5478.   [(set (pc)
  5479.     (if_then_else (match_operator 2 "comparison_operator"
  5480.                       [(match_operand:SI 1 "gpc_reg_operand" "")
  5481.                        (const_int 1)])
  5482.               (match_operand 5 "" "")
  5483.               (match_operand 6 "" "")))
  5484.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  5485.     (plus:SI (match_dup 1) (const_int -1)))
  5486.    (clobber (match_scratch:CC 3 ""))
  5487.    (clobber (match_scratch:SI 4 ""))]
  5488.   "reload_completed"
  5489.   [(parallel [(set (match_dup 3)
  5490.            (compare:CC (plus:SI (match_dup 1) (const_int -1))
  5491.                    (const_int 0)))
  5492.           (set (match_dup 0) (plus:SI (match_dup 1) (const_int -1)))])
  5493.    (set (pc) (if_then_else (match_dup 7) (match_dup 5) (match_dup 6)))]
  5494.   "
  5495. { operands[7] = gen_rtx (GET_CODE (operands[2]), VOIDmode, operands[3],
  5496.              const0_rtx); }")
  5497.  
  5498. (define_split
  5499.   [(set (pc)
  5500.     (if_then_else (match_operator 2 "comparison_operator"
  5501.                       [(match_operand:SI 1 "gpc_reg_operand" "")
  5502.                        (const_int 1)])
  5503.               (match_operand 5 "" "")
  5504.               (match_operand 6 "" "")))
  5505.    (set (match_operand:SI 0 "general_operand" "")
  5506.     (plus:SI (match_dup 1) (const_int -1)))
  5507.    (clobber (match_scratch:CC 3 ""))
  5508.    (clobber (match_scratch:SI 4 ""))]
  5509.   "reload_completed && ! gpc_reg_operand (operands[0], SImode)"
  5510.   [(parallel [(set (match_dup 3)
  5511.            (compare:CC (plus:SI (match_dup 1) (const_int -1))
  5512.                    (const_int 0)))
  5513.           (set (match_dup 4) (plus:SI (match_dup 1) (const_int -1)))])
  5514.    (set (match_dup 0) (match_dup 4))
  5515.    (set (pc) (if_then_else (match_dup 7) (match_dup 5) (match_dup 6)))]
  5516.   "
  5517. { operands[7] = gen_rtx (GET_CODE (operands[2]), VOIDmode, operands[3],
  5518.              const0_rtx); }")
  5519.